Cataclysm BN
game Class Reference

#include <game.h>

Classes

class  Creature_range
 
class  debug_hour_timer
 
class  draw_callback_t
 
class  monster_range
 
class  non_dead_range
 
class  npc_range
 

Public Member Functions

 game ()
 
 ~game ()
 
void load_static_data ()
 Loads static data that does not depend on mods or similar. More...
 
std::string get_player_base_save_path () const
 Base path for saving player data. More...
 
std::string get_world_base_save_path () const
 Base path for saving world data. More...
 
void on_options_changed ()
 Should be invoked whenever options change. More...
 
void setup ()
 
void serialize (std::ostream &fout)
 Saving and loading functions. More...
 
void unserialize (std::istream &fin)
 
void unserialize_master (std::istream &fin)
 
bool dump_stats (const std::string &what, dump_mode mode, const std::vector< std::string > &opts)
 write statistics to stdout and More...
 
bool save ()
 Returns false if saving failed. More...
 
std::vector< std::string > list_active_saves ()
 Returns a list of currently active character saves. More...
 
void write_memorial_file (const std::string &filename, std::string sLastWords)
 Writes information about the character out to a text file timestamped with the time of the file was made. More...
 
bool cleanup_at_end ()
 
void start_calendar ()
 
bool do_turn ()
 MAIN GAME LOOP. More...
 
shared_ptr_fast< ui_adaptorcreate_or_get_main_ui_adaptor ()
 
void invalidate_main_ui_adaptor () const
 
void mark_main_ui_adaptor_resize () const
 
void draw ()
 
void draw_ter (bool draw_sounds=true)
 
void draw_ter (const tripoint &center, bool looking=false, bool draw_sounds=true)
 
void add_draw_callback (shared_ptr_fast< draw_callback_t > cb)
 
void draw_panels (bool force_draw=false)
 
std::optional< tripointget_veh_dir_indicator_location (bool next) const
 Returns the location where the indicator should go relative to the reality bubble, or nothing to indicate no indicator should be drawn. More...
 
void draw_veh_dir_indicator (bool next)
 
void vertical_move (int z, bool force, bool peeking=false)
 Moves the player vertically. More...
 
void start_hauling (const tripoint &pos)
 
std::optional< tripointfind_or_make_stairs (map &mp, int z_after, bool &rope_ladder, bool peeking)
 Returns the other end of the stairs (if any). More...
 
void vertical_shift (int z_after)
 Actual z-level movement part of vertical_move. More...
 
void vertical_notes (int z_before, int z_after)
 Add goes up/down auto_notes (if turned on) More...
 
void use_computer (const tripoint &p)
 Checks to see if a player can use a computer (not illiterate, etc.) and uses if able. More...
 
template<typename T = Creature>
T * critter_by_id (const character_id &id)
 
template<typename T = Creature>
T * critter_at (const tripoint &p, bool allow_hallucination=false)
 Returns the Creature at the given location. More...
 
template<typename T = Creature>
const T * critter_at (const tripoint &p, bool allow_hallucination=false) const
 
template<typename T = Creature>
shared_ptr_fast< T > shared_from (const T &critter)
 Returns a shared pointer to the given critter (which can be of any of the subclasses of Creature). More...
 
size_t num_creatures () const
 Returns the approximate number of creatures in the reality bubble. More...
 
bool update_zombie_pos (const monster &critter, const tripoint &pos)
 Redirects to the creature_tracker update_pos() function. More...
 
void remove_zombie (const monster &critter)
 
void clear_zombies ()
 Redirects to the creature_tracker clear() function. More...
 
bool spawn_hallucination (const tripoint &p)
 Spawns a hallucination at a determined position. More...
 
bool swap_critters (Creature &, Creature &)
 Swaps positions of two creatures. More...
 
Creature_range all_creatures ()
 Returns an anonymous range that contains all creatures. More...
 
monster_range all_monsters ()
 Same as all_creatures but iterators only over monsters. More...
 
npc_range all_npcs ()
 Same as all_creatures but iterators only over npcs. More...
 
std::vector< Creature * > get_creatures_if (const std::function< bool(const Creature &)> &pred)
 Returns all creatures matching a predicate. More...
 
std::vector< npc * > get_npcs_if (const std::function< bool(const npc &)> &pred)
 
Creatureget_creature_if (const std::function< bool(const Creature &)> &pred)
 Returns a creature matching a predicate. More...
 
bool is_empty (const tripoint &p)
 Returns true if there is no player, NPC, or monster on the tile and move_cost > 0. More...
 
bool is_in_sunlight (const tripoint &p)
 Returns true if p is outdoors and it is sunny. More...
 
bool is_sheltered (const tripoint &p)
 Returns true if p is indoors, underground, or in a car. More...
 
bool revive_corpse (const tripoint &p, item &it)
 Revives a corpse at given location. More...
 
void save_cyborg (item *cyborg, const tripoint &couch_pos, player &installer)
 Turns Broken Cyborg monster into Cyborg NPC via surgery. More...
 
bool cancel_activity_query (const std::string &text)
 Asks if the player wants to cancel their activity, and if so cancels it. More...
 
bool cancel_activity_or_ignore_query (distraction_type type, const std::string &text)
 Asks if the player wants to cancel their activity and if so cancels it. More...
 
void moving_vehicle_dismount (const tripoint &dest_loc)
 Handles players exiting from moving vehicles. More...
 
vehicleremoteveh ()
 Returns the current remotely controlled vehicle. More...
 
void setremoteveh (vehicle *veh)
 Sets the current remotely controlled vehicle. More...
 
int assign_mission_id ()
 Returns the next available mission id. More...
 
npcfind_npc (character_id id)
 Find the npc with the given ID. More...
 
void load_npcs ()
 Makes any nearby NPCs on the overmap active. More...
 
void reload_npcs ()
 Unloads, then loads the NPCs. More...
 
const kill_trackerget_kill_tracker () const
 
void add_npc_follower (const character_id &id)
 Add follower id to set of followers. More...
 
void remove_npc_follower (const character_id &id)
 Remove follower id from follower set. More...
 
std::set< character_idget_follower_list ()
 Get set of followers. More...
 
void validate_npc_followers ()
 validate list of followers to account for overmap buffers More...
 
void validate_mounted_npcs ()
 
void validate_linked_vehicles ()
 validate towed vehicles so they get linked up again after a load More...
 
void validate_camps ()
 validate camps to ensure they are on the overmap list More...
 
void autopilot_vehicles ()
 process vehicles that are following the player More...
 
void catch_a_monster (monster *fish, const tripoint &pos, player *p, const time_duration &catch_duration)
 Picks and spawns a random fish from the remaining fish list when a fish is caught. More...
 
std::unordered_set< tripointget_fishable_locations (int distance, const tripoint &fish_pos)
 Get the contiguous fishable locations starting at fish_pos, out to the specificed distance. More...
 
std::vector< monster * > get_fishable_monsters (std::unordered_set< tripoint > &fishable_locations)
 Get the fishable monsters within the provided fishable locations. More...
 
void fling_creature (Creature *c, const units::angle &dir, float flvel, bool controlled=false)
 Flings the input creature in the given direction. More...
 
float natural_light_level (int zlev) const
 
unsigned char light_level (int zlev) const
 Returns coarse number-of-squares of visibility at the current light level. More...
 
void reset_light_level ()
 
character_id assign_npc_id ()
 
Creatureis_hostile_nearby ()
 
Creatureis_hostile_very_close ()
 
point update_map (player &p)
 
point update_map (int &x, int &y)
 
void update_overmap_seen ()
 
void process_artifact (item &it, player &p)
 
void add_artifact_messages (const std::vector< art_effect_passive > &effects)
 
void add_artifact_dreams ()
 
void peek ()
 
void peek (const tripoint &p)
 
std::optional< tripointlook_debug ()
 
bool check_zone (const zone_type_id &type, const tripoint &where) const
 
bool check_near_zone (const zone_type_id &type, const tripoint &where) const
 Checks whether or not there is a zone of particular type nearby. More...
 
bool is_zones_manager_open () const
 
void zones_manager ()
 
std::optional< tripointlook_around (bool force_3d=false)
 
look_around_result look_around (bool show_window, tripoint &center, const tripoint &start_point, bool has_first_point, bool select_zone, bool peeking, bool is_moving_zone=false, const tripoint &end_point=tripoint_zero, bool force_3d=false)
 
void pre_print_all_tile_info (const tripoint &lp, const catacurses::window &w_info, int &line, int last_line, const visibility_variables &cache)
 
void print_all_tile_info (const tripoint &lp, const catacurses::window &w_look, const std::string &area_name, int column, int &line, int last_line, const visibility_variables &cache)
 
void draw_look_around_cursor (const tripoint &lp, const visibility_variables &cache)
 
void extended_description (const tripoint &p)
 Long description of (visible) things at tile. More...
 
void draw_trail_to_square (const tripoint &t, bool bDrawX)
 
item_location inv_map_splice (item_filter filter, const std::string &title, int radius=0, const std::string &none_message="")
 Custom-filtered menu for inventory and nearby items and those that within specified radius. More...
 
bool has_gametype () const
 
special_game_type gametype () const
 
void toggle_fullscreen ()
 
void toggle_pixel_minimap ()
 
void reload_tileset (std::function< void(std::string)> out)
 
void temp_exit_fullscreen ()
 
void reenter_fullscreen ()
 
void zoom_in ()
 
void zoom_out ()
 
void reset_zoom ()
 
void set_zoom (int level)
 
int get_zoom () const
 
int get_moves_since_last_save () const
 
int get_user_action_counter () const
 
bool take_screenshot (const std::string &file_path) const
 Saves a screenshot of the current viewport, as a PNG file, to the given location. More...
 
bool take_screenshot () const
 Saves a screenshot of the current viewport, as a PNG file. More...
 
int get_levx () const
 The top left corner of the reality bubble (in submaps coordinates). More...
 
int get_levy () const
 
int get_levz () const
 
void load_map (const tripoint &pos_sm, bool pump_events=false)
 Load the main map at given location, see map::load, in global, absolute submap coordinates. More...
 
void load_map (const tripoint_abs_sm &pos_sm, bool pump_events=false)
 
overmapget_cur_om () const
 The overmap which contains the center submap of the reality bubble. More...
 
std::vector< npc * > allies ()
 Get all living player allies. More...
 
void set_driving_view_offset (point p)
 
void calc_driving_offset (vehicle *veh=nullptr)
 
void toggle_gate (const tripoint &p)
 
void knockback (const tripoint &s, const tripoint &t, int force, int stun, int dam_mult, Creature *source)
 
void knockback (std::vector< tripoint > &traj, int stun, int dam_mult, Creature *source)
 
void draw_bullet (const tripoint &t, int i, const std::vector< tripoint > &trajectory, char bullet)
 
void draw_hit_mon (const tripoint &p, const monster &m, bool dead=false)
 
void draw_hit_player (const Character &p, int dam)
 
void draw_line (const tripoint &p, const tripoint &center_point, const std::vector< tripoint > &points, bool noreveal=false)
 
void draw_line (const tripoint &p, const std::vector< tripoint > &points)
 
void draw_weather (const weather_printable &wPrint)
 
void draw_sct ()
 
void draw_zones (const tripoint &start, const tripoint &end, const tripoint &offset)
 
void draw_critter (const Creature &critter, const tripoint &center)
 
void draw_critter_highlighted (const Creature &critter, const tripoint &center)
 
void draw_cursor (const tripoint &p)
 
void draw_highlight (const tripoint &p)
 
void draw_radiation_override (const tripoint &p, int rad)
 
void draw_terrain_override (const tripoint &p, const ter_id &id)
 
void draw_furniture_override (const tripoint &p, const furn_id &id)
 
void draw_graffiti_override (const tripoint &p, bool has)
 
void draw_trap_override (const tripoint &p, const trap_id &id)
 
void draw_field_override (const tripoint &p, const field_type_id &id)
 
void draw_item_override (const tripoint &p, const itype_id &id, const mtype_id &mid, bool hilite)
 
void draw_vpart_override (const tripoint &p, const vpart_id &id, int part_mod, units::angle veh_dir, bool hilite, point mount)
 
void draw_below_override (const tripoint &p, bool draw)
 
void draw_monster_override (const tripoint &p, const mtype_id &id, int count, bool more, Creature::Attitude att)
 
bool is_in_viewport (const tripoint &p, int margin=0) const
 
bool check_safe_mode_allowed (bool repeat_safe_mode_warnings=true)
 Check whether movement is allowed according to safe mode settings. More...
 
void set_safe_mode (safe_mode_type mode)
 
void exam_vehicle (vehicle &veh, point cp=point_zero)
 open vehicle interaction screen More...
 
bool forced_door_closing (const tripoint &p, const ter_id &door_type, int bash_dmg)
 
bool load (const std::string &world)
 Attempt to load first valid save (if any) in world. More...
 
bool npc_menu (npc &who)
 Returns true if the menu handled stuff and player shouldn't do anything else. More...
 
bool phasing_move (const tripoint &dest, bool via_ramp=false)
 
bool walk_move (const tripoint &dest, bool via_ramp=false)
 
void on_move_effects ()
 
point place_player (const tripoint &dest)
 
void place_player_overmap (const tripoint_abs_omt &om_dest)
 
unsigned int get_seed () const
 
void set_npcs_dirty ()
 If invoked, NPCs will be reloaded before next turn. More...
 
void set_critter_died ()
 If invoked, dead will be cleaned this turn. More...
 
void mon_info (const catacurses::window &, int hor_padding=0)
 
void mon_info_update ()
 
void cleanup_dead ()
 
bool is_dangerous_tile (const tripoint &dest_loc) const
 
std::vector< std::string > get_dangerous_tile (const tripoint &dest_loc) const
 
bool prompt_dangerous_tile (const tripoint &dest_loc) const
 
void despawn_monster (monster &critter)
 Despawn a specific monster, it's stored on the overmap. More...
 
void win ()
 Marks the game as won. More...
 
bool disable_robot (const tripoint &p)
 If there is a robot (that can be disabled), query the player and try to disable it. More...
 
void draw_pixel_minimap (const catacurses::window &w)
 
void quicksave ()
 
void disp_NPCs ()
 
void list_missions ()
 
event_busevents ()
 
stats_trackerstats ()
 
memorial_loggermemorial ()
 
spell_eventsspell_events_subscriber ()
 
void display_toggle_overlay (action_id)
 
bool display_overlay_state (action_id)
 
void toggle_debug_hour_timer ()
 
tripoint mouse_edge_scrolling_terrain (input_context &ctxt)
 Used to implement mouse "edge scrolling". More...
 
tripoint mouse_edge_scrolling_overmap (input_context &ctxt)
 This variant is suitable for the overmap. More...
 
void shift_destination_preview (point delta)
 
bool slip_down ()
 Checks if player is able to successfully climb to/from some terrain and not slip down. More...
 
monsterplace_critter_at (const mtype_id &id, const tripoint &p)
 Adds critters to the reality bubble, creating them if necessary. More...
 
monsterplace_critter_at (const shared_ptr_fast< monster > &mon, const tripoint &p)
 
monsterplace_critter_around (const mtype_id &id, const tripoint &center, int radius)
 
monsterplace_critter_around (const shared_ptr_fast< monster > &mon, const tripoint &center, int radius, bool forced=false)
 
monsterplace_critter_within (const mtype_id &id, const tripoint_range< tripoint > &range)
 
monsterplace_critter_within (const shared_ptr_fast< monster > &mon, const tripoint_range< tripoint > &range)
 

Public Attributes

mapm
 
avataru
 
scent_mapscent
 
timed_event_managertimed_events
 
pimpl< Creature_trackercritter_tracker
 
pimpl< faction_managerfaction_manager_ptr
 
pimpl< drop_token_providertoken_provider_ptr
 
quit_status uquit
 Used in main.cpp to determine what type of quit is being performed. More...
 
bool new_game = false
 True if the game has just started or loaded, else false. More...
 
const scenarioscen = nullptr
 
std::vector< monstercoming_to_stairs
 
int monstairz = 0
 
tripoint ter_view_p
 
catacurses::window w_terrain
 
catacurses::window w_overmap
 
catacurses::window w_omlegend
 
catacurses::window w_minimap
 
catacurses::window w_pixel_minimap
 
point driving_view_offset
 
bool debug_pathfinding = false
 
bool debug_submap_grid_overlay = false
 
Creaturedisplaying_visibility_creature
 Creature for which to display the visibility map. More...
 
int displaying_lighting_condition = 0
 Type of lighting condition overlay to display. More...
 
bool show_panel_adm = false
 
bool right_sidebar = false
 
bool fullscreen = false
 
bool was_fullscreen = false
 
bool auto_travel_mode = false
 
bool queue_screenshot = false
 
safe_mode_type safe_mode
 
int turnssincelastmon = 0
 
int mostseen = 0
 

Private Types

enum class  vmenu_ret : int { CHANGE_TAB , QUIT , FIRE }
 

Private Member Functions

void unload_npcs ()
 Unloads all NPCs. More...
 
bool load (const save_t &name)
 
void load_master ()
 
bool start_game ()
 
bool save_factions_missions_npcs ()
 
void reset_npc_dispositions ()
 
void serialize_master (std::ostream &fout)
 
bool save_artifacts ()
 
bool save_maps ()
 
void init_autosave ()
 
void create_starting_npcs ()
 
vehicleplace_vehicle_nearby (const vproto_id &id, const point_abs_omt &origin, int min_distance, int max_distance, const std::vector< std::string > &omt_search_types={})
 
void list_items_monsters ()
 
game::vmenu_ret list_items (const std::vector< map_item_stack > &item_list)
 
std::vector< map_item_stackfind_nearby_items (int iRadius)
 
void reset_item_list_state (const catacurses::window &window, int height, bool bRadiusSort)
 
game::vmenu_ret list_monsters (const std::vector< Creature * > &monster_list)
 
bool grabbed_move (const tripoint &dp)
 Check for dangerous stuff at dest_loc, return false if the player decides not to step there. More...
 
bool grabbed_veh_move (const tripoint &dp)
 
bool grabbed_furn_move (const tripoint &dp)
 
void control_vehicle ()
 
void examine (const tripoint &p)
 
void examine ()
 
void pickup ()
 
void pickup (const tripoint &p)
 
void pickup_feet ()
 
void drop ()
 
void drop_in_direction ()
 
void butcher ()
 
void chat ()
 
void print_fields_info (const tripoint &lp, const catacurses::window &w_look, int column, int &line)
 
void print_terrain_info (const tripoint &lp, const catacurses::window &w_look, const std::string &area_name, int column, int &line)
 
void print_trap_info (const tripoint &lp, const catacurses::window &w_look, int column, int &line)
 
void print_creature_info (const Creature *creature, const catacurses::window &w_look, int column, int &line, int last_line)
 
void print_vehicle_info (const vehicle *veh, int veh_part, const catacurses::window &w_look, int column, int &line, int last_line)
 
void print_visibility_info (const catacurses::window &w_look, int column, int &line, visibility_type visibility)
 
void print_items_info (const tripoint &lp, const catacurses::window &w_look, int column, int &line, int last_line)
 
void print_graffiti_info (const tripoint &lp, const catacurses::window &w_look, int column, int &line, int last_line)
 
input_context get_player_input (std::string &action)
 
void replace_stair_monsters ()
 
void update_stair_monsters ()
 
void shift_monsters (const tripoint &shift)
 Shift all active monsters, the shift vector is the number of shifted submaps. More...
 
void perhaps_add_random_npc ()
 
void monmove ()
 
void overmap_npc_move ()
 
void process_voluntary_act_interrupt ()
 
void process_activity ()
 
void handle_key_blocking_activity ()
 
void open_consume_item_menu ()
 
bool handle_action ()
 
bool try_get_right_click_action (action_id &act, const tripoint &mouse_target)
 
bool try_get_left_click_action (action_id &act, const tripoint &mouse_target)
 
void item_action_menu ()
 
bool is_game_over ()
 
void death_screen ()
 
void win_screen ()
 
void draw_minimap ()
 
void autosave ()
 
void quickload ()
 
bool handle_mouseview (input_context &ctxt, std::string &action)
 
void display_faction_epilogues ()
 
void disp_NPC_epilogues ()
 
void display_scent ()
 
void display_temperature ()
 
void display_vehicle_ai ()
 
void display_visibility ()
 
void display_lighting ()
 
void display_radiation ()
 
void display_transparency ()
 
Creatureis_hostile_within (int distance)
 
void move_save_to_graveyard (const std::string &dirname)
 
bool save_player_data ()
 
std::pair< tripoint, tripointmouse_edge_scrolling (input_context &ctxt, int speed, const tripoint &last, bool iso)
 

Private Attributes

bool is_looking = false
 
std::vector< weak_ptr_fast< draw_callback_t > > draw_callbacks
 
std::optional< action_iddisplaying_overlays
 
class game::debug_hour_timer debug_hour_timer
 
pimpl< mapmap_ptr
 
pimpl< avataru_ptr
 
pimpl< live_viewliveview_ptr
 
live_viewliveview
 
pimpl< scent_mapscent_ptr
 
pimpl< timed_event_managertimed_event_manager_ptr
 
pimpl< event_busevent_bus_ptr
 
pimpl< stats_trackerstats_tracker_ptr
 
pimpl< achievements_trackerachievements_tracker_ptr
 
pimpl< kill_trackerkill_tracker_ptr
 
pimpl< memorial_loggermemorial_logger_ptr
 
pimpl< spell_eventsspell_events_ptr
 
pimpl< distribution_grid_trackergrid_tracker_ptr
 
pimpl< weather_managerweather_manager_ptr
 
shared_ptr_fast< playeru_shared_ptr
 
catacurses::window w_terrain_ptr
 
catacurses::window w_minimap_ptr
 
std::string sFilter
 
std::string list_item_upvote
 
std::string list_item_downvote
 
bool safe_mode_warning_logged = false
 
bool bVMonsterLookFire = false
 
character_id next_npc_id
 
std::list< shared_ptr_fast< npc > > active_npc
 
int next_mission_id = 0
 
std::set< character_idfollower_ids
 
int moves_since_last_save = 0
 
time_t last_save_timestamp
 
std::array< float, OVERMAP_LAYERSlatest_lightlevels
 
time_point remoteveh_cache_time
 
vehicleremoteveh_cache
 
bool npcs_dirty = false
 Has a NPC been spawned since last load? More...
 
bool critter_died = false
 Has anything died in this turn and needs to be cleaned up? More...
 
bool first_redraw_since_waiting_started = true
 Is this the first redraw since waiting (sleeping or activity) started. More...
 
bool zones_manager_open = false
 Is Zone manager open or not - changes graphics of some zone tiles. More...
 
std::unique_ptr< special_gamegamemode
 
int user_action_counter = 0
 
int tileset_zoom = 0
 How far the tileset should be zoomed out, 16 is default. More...
 
unsigned int seed = 0
 Seed for all the random numbers that should have consistent randomness (weather). More...
 
std::vector< tripointdestination_preview
 
std::chrono::time_point< std::chrono::steady_clock > last_mouse_edge_scroll
 
tripoint last_mouse_edge_scroll_vector_terrain
 
tripoint last_mouse_edge_scroll_vector_overmap
 
weak_ptr_fast< ui_adaptormain_ui_adaptor
 
std::unique_ptr< static_popupwait_popup
 

Friends

class editmap
 
class advanced_inventory
 
class main_menu
 
class monster_range
 
class Creature_range
 
distribution_grid_trackerget_distribution_grid_tracker ()
 Returns distribution grid tracker that is a part of the global game *g. More...
 
mapget_map ()
 
Characterget_player_character ()
 
avatarget_avatar ()
 
weather_managerget_weather ()
 

Detailed Description

Definition at line 143 of file game.h.

Member Enumeration Documentation

◆ vmenu_ret

enum class game::vmenu_ret : int
strongprivate
Enumerator
CHANGE_TAB 
QUIT 
FIRE 

Definition at line 768 of file game.h.

768 : int {
769 CHANGE_TAB,
770 QUIT,
771 FIRE, // Who knew, apparently you can do that in list_monsters
772 };

Constructor & Destructor Documentation

◆ game()

game::game ( )

Definition at line 300 of file game.cpp.

300 :
302 scent_ptr( *this ),
305 m( *map_ptr ),
306 u( *u_ptr ),
307 scent( *scent_ptr ),
309 uquit( QUIT_NO ),
310 new_game( false ),
312 mostseen( 0 ),
315 next_npc_id( 1 ),
316 next_mission_id( 1 ),
320 seed( 0 ),
321 last_mouse_edge_scroll( std::chrono::steady_clock::now() )
322{
330 world_generator = std::make_unique<worldfactory>();
331 // do nothing, everything that was in here is moved to init_data() which is called immediately after g = new game; in main.cpp
332 // The reason for this move is so that g is not uninitialized when it gets to installing the parts into vehicles.
333}
void subscribe(event_subscriber *)
Definition: event_bus.cpp:39
int mostseen
Definition: game.h:1022
pimpl< spell_events > spell_events_ptr
Definition: game.h:957
safe_mode_type safe_mode
Definition: game.h:1019
bool safe_mode_warning_logged
Definition: game.h:1033
pimpl< timed_event_manager > timed_event_manager_ptr
Definition: game.h:951
std::chrono::time_point< std::chrono::steady_clock > last_mouse_edge_scroll
Definition: game.h:1067
quit_status uquit
Used in main.cpp to determine what type of quit is being performed.
Definition: game.h:977
event_bus & events()
Definition: game.cpp:2717
pimpl< stats_tracker > stats_tracker_ptr
Definition: game.h:953
character_id next_npc_id
Definition: game.h:1035
pimpl< kill_tracker > kill_tracker_ptr
Definition: game.h:955
void reset_light_level()
Definition: game.cpp:3564
pimpl< memorial_logger > memorial_logger_ptr
Definition: game.h:956
shared_ptr_fast< player > u_shared_ptr
Definition: game.h:1024
pimpl< map > map_ptr
Definition: game.h:946
bool first_redraw_since_waiting_started
Is this the first redraw since waiting (sleeping or activity) started.
Definition: game.h:1050
pimpl< live_view > liveview_ptr
Definition: game.h:948
pimpl< achievements_tracker > achievements_tracker_ptr
Definition: game.h:954
pimpl< scent_map > scent_ptr
Definition: game.h:950
timed_event_manager & timed_events
Definition: game.h:965
unsigned int seed
Seed for all the random numbers that should have consistent randomness (weather).
Definition: game.h:1062
int next_mission_id
Definition: game.h:1037
bool new_game
True if the game has just started or loaded, else false.
Definition: game.h:979
pimpl< distribution_grid_tracker > grid_tracker_ptr
Definition: game.h:958
map & m
Definition: game.h:962
avatar & u
Definition: game.h:963
scent_map & scent
Definition: game.h:964
int user_action_counter
Definition: game.h:1056
live_view & liveview
Definition: game.h:949
int tileset_zoom
How far the tileset should be zoomed out, 16 is default.
Definition: game.h:1059
pimpl< avatar > u_ptr
Definition: game.h:947
time_point remoteveh_cache_time
Definition: game.h:1043
static void achievement_attained(const achievement *a)
Definition: game.cpp:293
static constexpr int DEFAULT_TILESET_ZOOM
Definition: game.h:41
@ SAFE_MODE_ON
Definition: game.h:78
@ QUIT_NO
Definition: game.h:68
mapbuffer MAPBUFFER
Definition: mapbuffer.cpp:40
const time_point before_time_starts
A time point that is always before the current turn, even when the game has just started.
Definition: calendar.cpp:25
For use with smart pointers when you don't actually want the deleter to do anything.
Definition: cata_utility.h:32
std::unique_ptr< worldfactory > world_generator

References achievements_tracker_ptr, events(), first_redraw_since_waiting_started, kill_tracker_ptr, memorial_logger_ptr, reset_light_level(), spell_events_ptr, stats_tracker_ptr, event_bus::subscribe(), and world_generator.

◆ ~game()

game::~game ( )
default

Member Function Documentation

◆ add_artifact_dreams()

void game::add_artifact_dreams ( )

Definition at line 11838 of file game.cpp.

11839{
11840 //If player is sleeping, get a dream from a carried artifact
11841 //Don't need to check that player is sleeping here, that's done before calling
11842 std::vector<item *> art_items = u.items_with( []( const item & it ) -> bool {
11843 return it.is_artifact();
11844 } );
11845 std::vector<item *> valid_arts;
11846 std::vector<std::vector<std::string>>
11847 valid_dreams; // Tracking separately so we only need to check its req once
11848 //Pull the list of dreams
11849 add_msg( m_debug, "Checking %s carried artifacts", art_items.size() );
11850 for( auto &it : art_items ) {
11851 //Pick only the ones with an applicable dream
11853 if( art && art->charge_req != ACR_NULL &&
11854 ( it->ammo_remaining() < it->ammo_capacity() ||
11855 it->ammo_capacity() == 0 ) ) { //or max 0 in case of wacky mod shenanigans
11856 add_msg( m_debug, "Checking artifact %s", it->tname() );
11857 if( check_art_charge_req( *it ) ) {
11858 add_msg( m_debug, " Has freq %s,%s", art->dream_freq_met, art->dream_freq_unmet );
11859 if( art->dream_freq_met > 0 && x_in_y( art->dream_freq_met, 100 ) ) {
11860 add_msg( m_debug, "Adding met dream from %s", it->tname() );
11861 valid_arts.push_back( it );
11862 valid_dreams.push_back( art->dream_msg_met );
11863 }
11864 } else {
11865 add_msg( m_debug, " Has freq %s,%s", art->dream_freq_met, art->dream_freq_unmet );
11866 if( art->dream_freq_unmet > 0 && x_in_y( art->dream_freq_unmet, 100 ) ) {
11867 add_msg( m_debug, "Adding unmet dream from %s", it->tname() );
11868 valid_arts.push_back( it );
11869 valid_dreams.push_back( art->dream_msg_unmet );
11870 }
11871 }
11872 }
11873 }
11874 if( !valid_dreams.empty() ) {
11875 add_msg( m_debug, "Found %s valid artifact dreams", valid_dreams.size() );
11876 const int selected = rng( 0, valid_arts.size() - 1 );
11877 auto it = valid_arts[selected];
11878 auto msg = random_entry( valid_dreams[selected] );
11879 const std::string &dream = string_format( _( msg ), it->tname() );
11880 add_msg( dream );
11881 } else {
11882 add_msg( m_debug, "Didn't have any dreams, sorry" );
11883 }
11884}
units::quantity< V, B > rng(const units::quantity< V, B > &min, const units::quantity< V, B > &max)
Definition: artifact.cpp:32
@ ACR_NULL
Definition: artifact.h:79
bool x_in_y(const time_duration &a, const time_duration &b)
Definition: calendar.cpp:521
This class is essentially a copyable unique pointer.
Definition: value_ptr.h:19
Definition: item.h:211
int ammo_remaining() const
Quantity of ammunition currently loaded in tool, gun or auxiliary gunmod.
Definition: item.cpp:7387
bool is_artifact() const
Definition: item.cpp:6968
int ammo_capacity() const
Maximum quantity of ammunition loadable for tool, gun or auxiliary gunmod.
Definition: item.cpp:7414
std::string tname(unsigned int quantity=1, bool with_prefix=true, unsigned int truncate=0) const
Return the (translated) item name.
Definition: item.cpp:4554
const itype * type
Definition: item.h:2164
std::vector< item * > items_with(const std::function< bool(const item &)> &filter)
Returns all items (including those within a container) matching the filter.
Definition: visitable.cpp:324
@ m_debug
Definition: enums.h:271
bool check_art_charge_req(item &it)
Definition: game.cpp:11541
void add_msg(std::string msg)
Definition: messages.cpp:910
V random_entry(const C &container, D default_value)
Returns a random entry in the container.
Definition: rng.h:88
std::string string_format(std::string_view format, Args &&...args)
Simple wrapper over string_formatter::parse.
cata::value_ptr< islot_artifact > artifact
Definition: itype.h:866
#define _(msg)
Definition: translations.h:116

References _, ACR_NULL, add_msg(), item::ammo_capacity(), item::ammo_remaining(), itype::artifact, check_art_charge_req(), item::is_artifact(), visitable< T >::items_with(), m_debug, random_entry(), rng(), string_format(), item::tname(), item::type, u, and x_in_y().

Referenced by do_turn().

◆ add_artifact_messages()

void game::add_artifact_messages ( const std::vector< art_effect_passive > &  effects)

Definition at line 11660 of file game.cpp.

11661{
11662 int net_str = 0;
11663 int net_dex = 0;
11664 int net_per = 0;
11665 int net_int = 0;
11666 int net_speed = 0;
11667
11668 for( auto &i : effects ) {
11669 switch( i ) {
11670 case AEP_STR_UP:
11671 net_str += 4;
11672 break;
11673 case AEP_DEX_UP:
11674 net_dex += 4;
11675 break;
11676 case AEP_PER_UP:
11677 net_per += 4;
11678 break;
11679 case AEP_INT_UP:
11680 net_int += 4;
11681 break;
11682 case AEP_ALL_UP:
11683 net_str += 2;
11684 net_dex += 2;
11685 net_per += 2;
11686 net_int += 2;
11687 break;
11688 case AEP_STR_DOWN:
11689 net_str -= 3;
11690 break;
11691 case AEP_DEX_DOWN:
11692 net_dex -= 3;
11693 break;
11694 case AEP_PER_DOWN:
11695 net_per -= 3;
11696 break;
11697 case AEP_INT_DOWN:
11698 net_int -= 3;
11699 break;
11700 case AEP_ALL_DOWN:
11701 net_str -= 2;
11702 net_dex -= 2;
11703 net_per -= 2;
11704 net_int -= 2;
11705 break;
11706
11707 case AEP_SPEED_UP:
11708 net_speed += 20;
11709 break;
11710 case AEP_SPEED_DOWN:
11711 net_speed -= 20;
11712 break;
11713
11714 case AEP_PBLUE:
11715 break; // No message
11716
11717 case AEP_SNAKES:
11718 add_msg( m_warning, _( "Your skin feels slithery." ) );
11719 break;
11720
11721 case AEP_INVISIBLE:
11722 add_msg( m_good, _( "You fade into invisibility!" ) );
11723 break;
11724
11725 case AEP_CLAIRVOYANCE:
11727 add_msg( m_good, _( "You can see through walls!" ) );
11728 break;
11729
11731 add_msg( m_good, _( "You can see through everything!" ) );
11732 break;
11733
11734 case AEP_STEALTH:
11735 add_msg( m_good, _( "Your steps stop making noise." ) );
11736 break;
11737
11738 case AEP_GLOW:
11739 add_msg( _( "A glow of light forms around you." ) );
11740 break;
11741
11742 case AEP_PSYSHIELD:
11743 add_msg( m_good, _( "Your mental state feels protected." ) );
11744 break;
11745
11747 add_msg( m_good, _( "You feel insulated." ) );
11748 break;
11749
11750 case AEP_CARRY_MORE:
11751 add_msg( m_good, _( "Your back feels strengthened." ) );
11752 break;
11753
11754 case AEP_FUN:
11755 add_msg( m_good, _( "You feel a pleasant tingle." ) );
11756 break;
11757
11758 case AEP_HUNGER:
11759 add_msg( m_warning, _( "You feel hungry." ) );
11760 break;
11761
11762 case AEP_THIRST:
11763 add_msg( m_warning, _( "You feel thirsty." ) );
11764 break;
11765
11766 case AEP_EVIL:
11767 add_msg( m_warning, _( "You feel an evil presence…" ) );
11768 break;
11769
11770 case AEP_SCHIZO:
11771 add_msg( m_bad, _( "You feel a tickle of insanity." ) );
11772 break;
11773
11774 case AEP_RADIOACTIVE:
11775 add_msg( m_warning, _( "Your skin prickles with radiation." ) );
11776 break;
11777
11778 case AEP_MUTAGENIC:
11779 add_msg( m_bad, _( "You feel your genetic makeup degrading." ) );
11780 break;
11781
11782 case AEP_ATTENTION:
11783 add_msg( m_warning, _( "You feel an otherworldly attention upon you…" ) );
11784 break;
11785
11786 case AEP_FORCE_TELEPORT:
11787 add_msg( m_bad, _( "You feel a force pulling you inwards." ) );
11788 break;
11789
11790 case AEP_MOVEMENT_NOISE:
11791 add_msg( m_warning, _( "You hear a rattling noise coming from inside yourself." ) );
11792 break;
11793
11794 case AEP_BAD_WEATHER:
11795 add_msg( m_warning, _( "You feel storms coming." ) );
11796 break;
11797
11798 case AEP_SICK:
11799 add_msg( m_bad, _( "You feel unwell." ) );
11800 break;
11801
11802 case AEP_SMOKE:
11803 add_msg( m_warning, _( "A cloud of smoke appears." ) );
11804 break;
11805 default:
11806 //Suppress warnings
11807 break;
11808 }
11809 }
11810
11811 std::string stat_info;
11812 if( net_str != 0 ) {
11813 stat_info += string_format( _( "Str %s%d! " ),
11814 ( net_str > 0 ? "+" : "" ), net_str );
11815 }
11816 if( net_dex != 0 ) {
11817 stat_info += string_format( _( "Dex %s%d! " ),
11818 ( net_dex > 0 ? "+" : "" ), net_dex );
11819 }
11820 if( net_int != 0 ) {
11821 stat_info += string_format( _( "Int %s%d! " ),
11822 ( net_int > 0 ? "+" : "" ), net_int );
11823 }
11824 if( net_per != 0 ) {
11825 stat_info += string_format( _( "Per %s%d! " ),
11826 ( net_per > 0 ? "+" : "" ), net_per );
11827 }
11828
11829 if( !stat_info.empty() ) {
11830 add_msg( m_neutral, stat_info );
11831 }
11832
11833 if( net_speed != 0 ) {
11834 add_msg( m_info, _( "Speed %s%d!" ), ( net_speed > 0 ? "+" : "" ), net_speed );
11835 }
11836}
@ m_good
Definition: enums.h:260
@ m_neutral
Definition: enums.h:267
@ m_info
Definition: enums.h:265
@ m_bad
Definition: enums.h:261
@ m_warning
Definition: enums.h:264
@ AEP_GLOW
Definition: enums.h:115
@ AEP_MUTAGENIC
Definition: enums.h:130
@ AEP_ALL_UP
Definition: enums.h:106
@ AEP_INT_UP
Definition: enums.h:105
@ AEP_INT_DOWN
Definition: enums.h:135
@ AEP_PER_UP
Definition: enums.h:104
@ AEP_PSYSHIELD
Definition: enums.h:116
@ AEP_CLAIRVOYANCE_PLUS
Definition: enums.h:142
@ AEP_MOVEMENT_NOISE
Definition: enums.h:139
@ AEP_STEALTH
Definition: enums.h:113
@ AEP_CARRY_MORE
Definition: enums.h:118
@ AEP_THIRST
Definition: enums.h:125
@ AEP_SPEED_UP
Definition: enums.h:107
@ AEP_EVIL
Definition: enums.h:127
@ AEP_ALL_DOWN
Definition: enums.h:136
@ AEP_DEX_UP
Definition: enums.h:103
@ AEP_SCHIZO
Definition: enums.h:128
@ AEP_DEX_DOWN
Definition: enums.h:133
@ AEP_FUN
Definition: enums.h:120
@ AEP_PER_DOWN
Definition: enums.h:134
@ AEP_FORCE_TELEPORT
Definition: enums.h:138
@ AEP_ATTENTION
Definition: enums.h:131
@ AEP_RADIOACTIVE
Definition: enums.h:129
@ AEP_SUPER_CLAIRVOYANCE
Definition: enums.h:112
@ AEP_BAD_WEATHER
Definition: enums.h:140
@ AEP_SICK
Definition: enums.h:141
@ AEP_CLAIRVOYANCE
Definition: enums.h:111
@ AEP_INVISIBLE
Definition: enums.h:110
@ AEP_STR_UP
Definition: enums.h:102
@ AEP_STR_DOWN
Definition: enums.h:132
@ AEP_HUNGER
Definition: enums.h:124
@ AEP_RESIST_ELECTRICITY
Definition: enums.h:117
@ AEP_PBLUE
Definition: enums.h:108
@ AEP_SPEED_DOWN
Definition: enums.h:137
@ AEP_SNAKES
Definition: enums.h:109
@ AEP_SMOKE
Definition: enums.h:126

References _, add_msg(), AEP_ALL_DOWN, AEP_ALL_UP, AEP_ATTENTION, AEP_BAD_WEATHER, AEP_CARRY_MORE, AEP_CLAIRVOYANCE, AEP_CLAIRVOYANCE_PLUS, AEP_DEX_DOWN, AEP_DEX_UP, AEP_EVIL, AEP_FORCE_TELEPORT, AEP_FUN, AEP_GLOW, AEP_HUNGER, AEP_INT_DOWN, AEP_INT_UP, AEP_INVISIBLE, AEP_MOVEMENT_NOISE, AEP_MUTAGENIC, AEP_PBLUE, AEP_PER_DOWN, AEP_PER_UP, AEP_PSYSHIELD, AEP_RADIOACTIVE, AEP_RESIST_ELECTRICITY, AEP_SCHIZO, AEP_SICK, AEP_SMOKE, AEP_SNAKES, AEP_SPEED_DOWN, AEP_SPEED_UP, AEP_STEALTH, AEP_STR_DOWN, AEP_STR_UP, AEP_SUPER_CLAIRVOYANCE, AEP_THIRST, m_bad, m_good, m_info, m_neutral, m_warning, and string_format().

◆ add_draw_callback()

void game::add_draw_callback ( shared_ptr_fast< draw_callback_t cb)

Definition at line 3015 of file game.cpp.

3016{
3017 draw_callbacks.erase(
3018 std::remove_if( draw_callbacks.begin(), draw_callbacks.end(),
3019 []( const weak_ptr_fast<draw_callback_t> &cbw ) {
3020 return cbw.expired();
3021 } ),
3022 draw_callbacks.end()
3023 );
3024 draw_callbacks.emplace_back( cb );
3025 cb->added = true;
3027}
void invalidate_main_ui_adaptor() const
Definition: game.cpp:2980
std::vector< weak_ptr_fast< draw_callback_t > > draw_callbacks
Definition: game.h:225
std::weak_ptr< T > weak_ptr_fast
Definition: memory_fast.h:17

References draw_callbacks, and invalidate_main_ui_adaptor().

Referenced by get_player_input(), list_items(), list_monsters(), look_around(), pickup(), and zones_manager().

◆ add_npc_follower()

void game::add_npc_follower ( const character_id id)

Add follower id to set of followers.

Definition at line 1884 of file game.cpp.

1885{
1886 follower_ids.insert( id );
1887 u.follower_ids.insert( id );
1888}
std::set< character_id > follower_ids
Definition: game.h:1038
std::set< character_id > follower_ids
Definition: player.h:261

References follower_ids, player::follower_ids, and u.

Referenced by validate_npc_followers().

◆ all_creatures()

game::Creature_range game::all_creatures ( )

Returns an anonymous range that contains all creatures.

The range allows iteration via a range-based for loop, e.g. for( Creature &critter : all_creatures() ) { ... }. One shall not store the returned range nor the iterators. One can freely remove and add creatures to the game during the iteration. Added creatures will not be iterated over.

Definition at line 11996 of file game.cpp.

11997{
11998 return Creature_range( *this );
11999}
friend class Creature_range
Definition: game.h:334

References Creature_range.

Referenced by draw_ter(), get_creature_if(), and get_creatures_if().

◆ all_monsters()

game::monster_range game::all_monsters ( )

Same as all_creatures but iterators only over monsters.

Definition at line 12001 of file game.cpp.

12002{
12003 return monster_range( *this );
12004}
friend class monster_range
Definition: game.h:333

References monster_range.

Referenced by cleanup_at_end(), disp_NPCs(), get_fishable_monsters(), monmove(), place_player_overmap(), shift_monsters(), start_game(), validate_mounted_npcs(), and vertical_move().

◆ all_npcs()

game::npc_range game::all_npcs ( )

Same as all_creatures but iterators only over npcs.

Definition at line 12006 of file game.cpp.

12007{
12008 return npc_range( *this );
12009}

Referenced by do_turn(), and get_npcs_if().

◆ allies()

std::vector< npc * > game::allies ( )

Get all living player allies.

Definition at line 11910 of file game.cpp.

11911{
11912 return get_npcs_if( [&]( const npc & guy ) {
11913 if( !guy.is_hallucination() ) {
11914 return guy.is_ally( g->u );
11915 } else {
11916 return false;
11917 }
11918 } );
11919}
std::vector< npc * > get_npcs_if(const std::function< bool(const npc &)> &pred)
Definition: game.cpp:11933
Definition: npc.h:744
bool is_hallucination() const override
Definition: npc.cpp:3304

References get_npcs_if(), and npc::is_hallucination().

◆ assign_mission_id()

int game::assign_mission_id ( )

Returns the next available mission id.

Definition at line 1872 of file game.cpp.

1873{
1874 int ret = next_mission_id;
1876 return ret;
1877}

References next_mission_id, and cata::hash64_detail::ret.

◆ assign_npc_id()

character_id game::assign_npc_id ( )

Definition at line 3572 of file game.cpp.

3573{
3575 ++next_npc_id;
3576 return ret;
3577}

References next_npc_id, and cata::hash64_detail::ret.

Referenced by load(), and start_game().

◆ autopilot_vehicles()

void game::autopilot_vehicles ( )

process vehicles that are following the player

Definition at line 1671 of file game.cpp.

1672{
1673 for( wrapped_vehicle &veh : m.get_vehicles() ) {
1674 vehicle *&v = veh.v;
1675 if( v->is_following ) {
1676 v->drive_to_local_target( m.getabs( u.pos() ), true );
1677 } else if( v->is_patrolling ) {
1678 v->autopilot_patrol();
1679 }
1680 }
1681}
const tripoint & pos() const override
Definition: character.cpp:598
tripoint getabs(const tripoint &p) const
Translates local (to this map) coordinates of a square to global absolute coordinates.
Definition: map.cpp:8378
VehicleList get_vehicles()
Definition: map.cpp:296
A vehicle as a whole with all its components.
Definition: vehicle.h:676
void autopilot_patrol()
Definition: vehicle.cpp:702
bool is_following
Definition: vehicle.h:2008
bool is_patrolling
Definition: vehicle.h:2009
void drive_to_local_target(const tripoint &target, bool follow_protocol)
Definition: vehicle.cpp:817

References vehicle::autopilot_patrol(), vehicle::drive_to_local_target(), map::get_vehicles(), map::getabs(), vehicle::is_following, vehicle::is_patrolling, m, Character::pos(), and u.

Referenced by do_turn().

◆ autosave()

void game::autosave ( )
private

Definition at line 11327 of file game.cpp.

11328{
11329 //Don't autosave if the min-autosave interval has not passed since the last autosave/quicksave.
11330 if( time( nullptr ) < last_save_timestamp + 60 * get_option<int>( "AUTOSAVE_MINUTES" ) ) {
11331 return;
11332 }
11333 quicksave(); //Driving checks are handled by quicksave()
11334}
time_t last_save_timestamp
Definition: game.h:1040
void quicksave()
Definition: game.cpp:11282
@ time
Recharges slowly with time.

References last_save_timestamp, quicksave(), and time.

Referenced by do_turn().

◆ butcher()

void game::butcher ( )
private

Definition at line 8309 of file game.cpp.

8310{
8311 static const std::string salvage_string = "salvage";
8312 if( u.controlling_vehicle ) {
8313 add_msg( m_info, _( "You can't butcher while driving!" ) );
8314 return;
8315 }
8316
8317 const int factor = u.max_quality( quality_id( "BUTCHER" ) );
8318 const int factorD = u.max_quality( quality_id( "CUT_FINE" ) );
8319 const std::string no_knife_msg = _( "You don't have a butchering tool." );
8320 const std::string no_corpse_msg = _( "There are no corpses here to butcher." );
8321
8322 //You can't butcher on sealed terrain- you have to smash/shovel/etc it open first
8323 if( m.has_flag( "SEALED", u.pos() ) ) {
8324 if( m.sees_some_items( u.pos(), u ) ) {
8325 add_msg( m_info, _( "You can't access the items here." ) );
8326 } else if( factor > INT_MIN || factorD > INT_MIN ) {
8327 add_msg( m_info, no_corpse_msg );
8328 } else {
8329 add_msg( m_info, no_knife_msg );
8330 }
8331 return;
8332 }
8333
8334 const item *first_item_without_tools = nullptr;
8335 // Indices of relevant items
8336 std::vector<map_stack::iterator> corpses;
8337 std::vector<map_stack::iterator> disassembles;
8338 std::vector<map_stack::iterator> salvageables;
8339 map_stack items = m.i_at( u.pos() );
8340 const inventory &crafting_inv = u.crafting_inventory();
8341
8342 // TODO: Properly handle different material whitelists
8343 // TODO: Improve quality of this section
8344 auto salvage_filter = []( item it ) {
8345 const auto usable = it.get_usable_item( salvage_string );
8346 return usable != nullptr;
8347 };
8348
8349 std::vector< item * > salvage_tools = u.items_with( salvage_filter );
8350 int salvage_tool_index = INT_MIN;
8351 item *salvage_tool = nullptr;
8352 const salvage_actor *salvage_iuse = nullptr;
8353 if( !salvage_tools.empty() ) {
8354 salvage_tool = salvage_tools.front();
8355 salvage_tool_index = u.get_item_position( salvage_tool );
8356 item *usable = salvage_tool->get_usable_item( salvage_string );
8357 salvage_iuse = dynamic_cast<const salvage_actor *>(
8358 usable->get_use( salvage_string )->get_actor_ptr() );
8359 }
8360
8361 // Reserve capacity for each to hold entire item set if necessary to prevent
8362 // reallocations later on
8363 corpses.reserve( items.size() );
8364 salvageables.reserve( items.size() );
8365 disassembles.reserve( items.size() );
8366
8367 // Split into corpses, disassemble-able, and salvageable items
8368 // It's not much additional work to just generate a corpse list and
8369 // clear it later, but does make the splitting process nicer.
8370 for( map_stack::iterator it = items.begin(); it != items.end(); ++it ) {
8371 if( it->is_corpse() ) {
8372 corpses.push_back( it );
8373 } else {
8374 if( ( salvage_tool_index != INT_MIN ) && salvage_iuse->valid_to_cut_up( *it ) ) {
8375 salvageables.push_back( it );
8376 }
8377 if( crafting::can_disassemble( u, *it, crafting_inv ).success() ) {
8378 disassembles.push_back( it );
8379 } else if( !first_item_without_tools ) {
8380 first_item_without_tools = &*it;
8381 }
8382 }
8383 }
8384
8385 // Clear corpses if butcher and dissect factors are INT_MIN
8386 if( factor == INT_MIN && factorD == INT_MIN ) {
8387 corpses.clear();
8388 }
8389
8390 if( corpses.empty() && disassembles.empty() && salvageables.empty() ) {
8391 if( factor > INT_MIN || factorD > INT_MIN ) {
8392 add_msg( m_info, no_corpse_msg );
8393 } else {
8394 add_msg( m_info, no_knife_msg );
8395 }
8396
8397 if( first_item_without_tools ) {
8398 add_msg( m_info, _( "You don't have the necessary tools to disassemble any items here." ) );
8399 // Just for the "You need x to disassemble y" messages
8400 const auto ret = crafting::can_disassemble( u, *first_item_without_tools, crafting_inv );
8401 if( !ret.success() ) {
8402 add_msg( m_info, "%s", ret.c_str() );
8403 }
8404 }
8405 return;
8406 }
8407
8408 Creature *hostile_critter = is_hostile_very_close();
8409 if( hostile_critter != nullptr ) {
8410 if( !query_yn( _( "You see %s nearby! Start butchering anyway?" ),
8411 hostile_critter->disp_name() ) ) {
8412 return;
8413 }
8414 }
8415
8416 // Magic indices for special butcher options
8417 enum : int {
8418 MULTISALVAGE = MAX_ITEM_IN_SQUARE + 1,
8419 MULTIBUTCHER,
8420 MULTIDISASSEMBLE_ONE,
8421 MULTIDISASSEMBLE_ALL,
8422 NUM_BUTCHER_ACTIONS
8423 };
8424 // What are we butchering (i.e.. which vector to pick indices from)
8425 enum {
8426 BUTCHER_CORPSE,
8427 BUTCHER_DISASSEMBLE,
8428 BUTCHER_SALVAGE,
8429 BUTCHER_OTHER // For multisalvage etc.
8430 } butcher_select = BUTCHER_CORPSE;
8431 // Index to std::vector of iterators...
8432 int indexer_index = 0;
8433
8434 // Generate the indexed stacks so we can display them nicely
8435 const auto disassembly_stacks = generate_butcher_stack_display( disassembles );
8436 const auto salvage_stacks = generate_butcher_stack_display( salvageables );
8437 // Always ask before cutting up/disassembly, but not before butchery
8438 size_t ret = 0;
8439 if( !corpses.empty() || !disassembles.empty() || !salvageables.empty() ) {
8440 uilist kmenu;
8441 kmenu.text = _( "Choose corpse to butcher / item to disassemble" );
8442
8443 size_t i = 0;
8444 // Add corpses, disassembleables, and salvagables to the UI
8445 add_corpses( kmenu, corpses, i );
8446 add_disassemblables( kmenu, disassembly_stacks, i );
8447 if( salvage_iuse && !salvageables.empty() ) {
8448 add_salvagables( kmenu, salvage_stacks, i, *salvage_iuse );
8449 }
8450
8451 if( corpses.size() > 1 ) {
8452 kmenu.addentry( MULTIBUTCHER, true, 'b', _( "Butcher everything" ) );
8453 }
8454 if( disassembles.size() > 1 ) {
8455 int time_to_disassemble = 0;
8456 int time_to_disassemble_all = 0;
8457 for( const auto &stack : disassembly_stacks ) {
8458 const int time = recipe_dictionary::get_uncraft( stack.first->typeId() ).time;
8459 time_to_disassemble += time;
8460 time_to_disassemble_all += time * stack.second;
8461 }
8462
8463 kmenu.addentry_col( MULTIDISASSEMBLE_ONE, true, 'D', _( "Disassemble everything once" ),
8464 to_string_clipped( time_duration::from_turns( time_to_disassemble / 100 ) ) );
8465 kmenu.addentry_col( MULTIDISASSEMBLE_ALL, true, 'd', _( "Disassemble everything recursively" ),
8466 to_string_clipped( time_duration::from_turns( time_to_disassemble_all / 100 ) ) );
8467 }
8468 if( salvage_iuse && salvageables.size() > 1 ) {
8469 int time_to_salvage = 0;
8470 for( const auto &stack : salvage_stacks ) {
8471 time_to_salvage += salvage_iuse->time_to_cut_up( *stack.first ) * stack.second;
8472 }
8473
8474 kmenu.addentry_col( MULTISALVAGE, true, 'z', _( "Cut up everything" ),
8475 to_string_clipped( time_duration::from_turns( time_to_salvage / 100 ) ) );
8476 }
8477
8478 kmenu.query();
8479
8480 if( kmenu.ret < 0 || kmenu.ret >= NUM_BUTCHER_ACTIONS ) {
8481 return;
8482 }
8483
8484 ret = static_cast<size_t>( kmenu.ret );
8485 if( ret >= MULTISALVAGE && ret < NUM_BUTCHER_ACTIONS ) {
8486 butcher_select = BUTCHER_OTHER;
8487 indexer_index = ret;
8488 } else if( ret < corpses.size() ) {
8489 butcher_select = BUTCHER_CORPSE;
8490 indexer_index = ret;
8491 } else if( ret < corpses.size() + disassembly_stacks.size() ) {
8492 butcher_select = BUTCHER_DISASSEMBLE;
8493 indexer_index = ret - corpses.size();
8494 } else if( ret < corpses.size() + disassembly_stacks.size() + salvage_stacks.size() ) {
8495 butcher_select = BUTCHER_SALVAGE;
8496 indexer_index = ret - corpses.size() - disassembly_stacks.size();
8497 } else {
8498 debugmsg( "Invalid butchery index: %d", ret );
8499 return;
8500 }
8501 }
8502
8503 if( !u.has_morale_to_craft() ) {
8504 if( butcher_select == BUTCHER_CORPSE || indexer_index == MULTIBUTCHER ) {
8505 add_msg( m_info,
8506 _( "You are not in the mood and the prospect of guts and blood on your hands convinces you to turn away." ) );
8507 } else {
8508 add_msg( m_info,
8509 _( "You are not in the mood and the prospect of work stops you before you begin." ) );
8510 }
8511 return;
8512 }
8513 const auto helpers = character_funcs::get_crafting_helpers( u );
8514 for( const npc *np : helpers ) {
8515 add_msg( m_info, _( "%s helps with this task…" ), np->name );
8516 }
8517 switch( butcher_select ) {
8518 case BUTCHER_OTHER:
8519 switch( indexer_index ) {
8520 case MULTISALVAGE:
8521 u.assign_activity( activity_id( "ACT_LONGSALVAGE" ), 0, salvage_tool_index );
8522 break;
8523 case MULTIBUTCHER:
8524 butcher_submenu( corpses );
8525 for( map_stack::iterator &it : corpses ) {
8526 u.activity.targets.emplace_back( map_cursor( u.pos() ), &*it );
8527 }
8528 break;
8529 case MULTIDISASSEMBLE_ONE:
8530 crafting::disassemble_all( u, false );
8531 break;
8532 case MULTIDISASSEMBLE_ALL:
8534 break;
8535 default:
8536 debugmsg( "Invalid butchery type: %d", indexer_index );
8537 return;
8538 }
8539 break;
8540 case BUTCHER_CORPSE: {
8541 butcher_submenu( corpses, indexer_index );
8542 u.activity.targets.emplace_back( map_cursor( u.pos() ), &*corpses[indexer_index] );
8543 }
8544 break;
8545 case BUTCHER_DISASSEMBLE: {
8546 // Pick index of first item in the disassembly stack
8547 item *const target = &*disassembly_stacks[indexer_index].first;
8549 }
8550 break;
8551 case BUTCHER_SALVAGE: {
8552 if( !salvage_iuse || !salvage_tool ) {
8553 debugmsg( "null salve_iuse or salvage_tool" );
8554 } else {
8555 // Pick index of first item in the salvage stack
8556 item *const target = &*salvage_stacks[indexer_index].first;
8557 item_location item_loc( map_cursor( u.pos() ), target );
8558 salvage_iuse->cut_up( u, *salvage_tool, item_loc );
8559 }
8560 }
8561 break;
8562 }
8563}
string_id< activity_type > activity_id
Definition: activity_type.h:15
static std::string to_string_clipped(const int num, const clipped_unit type, const clipped_align align)
Definition: calendar.cpp:228
bool controlling_vehicle
Definition: character.h:254
player_activity activity
Definition: character.h:1573
int get_item_position(const item *it) const
Returns the item position (suitable for i_at or similar) of a specific item.
Definition: character.cpp:2349
bool has_morale_to_craft() const
Definition: crafting.cpp:336
const inventory & crafting_inventory(bool clear_path)
Definition: crafting.cpp:556
void assign_activity(const activity_id &type, int moves=calendar::INDEFINITELY_LONG, int index=-1, int pos=INT_MIN, const std::string &name="")
Legacy activity assignment, does not work for any activites using the new activity_actor class and ma...
Definition: character.cpp:9171
virtual std::string disp_name(bool possessive=false, bool capitalize_first=false) const =0
Creature * is_hostile_very_close()
Definition: game.cpp:3586
A lightweight handle to an item independent of it's location Unlike a raw pointer can be (de-)seriali...
Definition: item_location.h:23
size_t size() const
Definition: item_stack.cpp:10
iterator begin()
Definition: item_stack.cpp:28
iterator end()
Definition: item_stack.cpp:33
item * get_usable_item(const std::string &use_name)
Checks this item and its contents (recursively) for types that have use_function with type use_name.
Definition: item.cpp:7974
const use_function * get_use(const std::string &use_name) const
Returns the pointer to use_function with name use_name assigned to the type of this item or any of it...
Definition: item.cpp:7948
Definition: map.h:105
bool has_flag(const std::string &flag, const tripoint &p) const
Definition: map.cpp:2374
map_stack i_at(const tripoint &p)
Definition: map.cpp:4188
bool sees_some_items(const tripoint &p, const Creature &who) const
Check if creature can see some items at p.
Definition: map.cpp:4834
std::vector< item_location > targets
static const recipe & get_uncraft(const itype_id &id)
Returns disassembly recipe (or null recipe if no match)
int time
Definition: recipe.h:61
Cuts stuff up into components.
Definition: iuse_actor.h:567
bool valid_to_cut_up(const item &it) const
int cut_up(player &p, item &it, item_location &cut) const
int time_to_cut_up(const item &it) const
static constexpr time_duration from_turns(const T t)
Named constructors to get a duration representing a multiple of the named time units.
Definition: calendar.h:204
uilist: scrolling vertical list menu
Definition: ui.h:187
int ret
Definition: ui.h:412
void addentry_col(int r, bool e, int k, const std::string &str, const std::string &column, const std::string &desc="")
Definition: ui.cpp:962
std::string text
Definition: ui.h:320
void addentry(const std::string &str)
Definition: ui.cpp:942
int max_quality(const quality_id &qual) const
Return maximum tool quality level provided by instance or INT_MIN if not found.
Definition: visitable.cpp:276
#define debugmsg(...)
Debug message of level DL::Error and class DC::DebugMsg, also includes the source file name and line,...
Definition: debug.h:74
static void butcher_submenu(const std::vector< map_stack::iterator > &corpses, int corpse=-1)
Definition: game.cpp:8159
static void add_salvagables(uilist &menu, const std::vector< std::pair< map_stack::iterator, int > > &stacks, size_t &menu_index, const salvage_actor &salvage_iuse)
Definition: game.cpp:8117
static void add_disassemblables(uilist &menu, const std::vector< std::pair< map_stack::iterator, int > > &stacks, size_t &menu_index)
Definition: game.cpp:8138
static std::vector< std::pair< map_stack::iterator, int > > generate_butcher_stack_display(const std::vector< map_stack::iterator > &its)
Definition: game.cpp:8070
static void add_corpses(uilist &menu, const std::vector< map_stack::iterator > &its, size_t &menu_index)
Definition: game.cpp:8105
static constexpr int MAX_ITEM_IN_SQUARE
void query(bool loop=true, int timeout=-1)
Handle input and update display.
Definition: ui.cpp:838
std::vector< npc * > get_crafting_helpers(const Character &who, int max)
Returns nearby NPCs ready and willing to help with crafting or some other manual task.
ret_val< bool > can_disassemble(const Character &who, const item &obj, const inventory &inv)
Check if character can disassemble an item using the given crafting inventory.
Definition: crafting.cpp:1880
bool disassemble(avatar &you)
Prompt for an item to disassemble, then start activity.
Definition: crafting.cpp:2064
bool disassemble_all(avatar &you, bool recursively)
Start an activity to disassemble all items in avatar's square.
Definition: crafting.cpp:2075
bool query_yn(const std::string &text)
Definition: output.cpp:698
iuse_actor * get_actor_ptr()
Definition: iuse.h:315
string_id< quality > quality_id
Definition: type_id.h:184

References _, Character::activity, add_corpses(), add_disassemblables(), add_msg(), add_salvagables(), uilist::addentry(), uilist::addentry_col(), Character::assign_activity(), item_stack::begin(), butcher_submenu(), crafting::can_disassemble(), Character::controlling_vehicle, Character::crafting_inventory(), salvage_actor::cut_up(), debugmsg, crafting::disassemble(), crafting::disassemble_all(), Creature::disp_name(), item_stack::end(), time_duration::from_turns(), generate_butcher_stack_display(), use_function::get_actor_ptr(), character_funcs::get_crafting_helpers(), Character::get_item_position(), recipe_dictionary::get_uncraft(), item::get_usable_item(), item::get_use(), map::has_flag(), Character::has_morale_to_craft(), map::i_at(), is_hostile_very_close(), visitable< T >::items_with(), m, m_info, MAX_ITEM_IN_SQUARE, visitable< T >::max_quality(), Character::pos(), uilist::query(), query_yn(), cata::hash64_detail::ret, uilist::ret, map::sees_some_items(), item_stack::size(), player_activity::targets, uilist::text, recipe::time, time, salvage_actor::time_to_cut_up(), to_string_clipped(), u, and salvage_actor::valid_to_cut_up().

Referenced by handle_action().

◆ calc_driving_offset()

void game::calc_driving_offset ( vehicle veh = nullptr)

Definition at line 1251 of file game.cpp.

1252{
1253 if( veh == nullptr || !get_option<bool>( "DRIVING_VIEW_OFFSET" ) ) {
1255 return;
1256 }
1257 const int g_light_level = static_cast<int>( light_level( u.posz() ) );
1258 const int light_sight_range = u.sight_range( g_light_level );
1259 int sight = std::max( veh_lumi( *veh ), light_sight_range );
1260
1261 // The maximal offset will leave at least this many tiles
1262 // between the PC and the edge of the main window.
1263 static const int border_range = 2;
1264 point max_offset( ( getmaxx( w_terrain ) + 1 ) / 2 - border_range - 1,
1265 ( getmaxy( w_terrain ) + 1 ) / 2 - border_range - 1 );
1266
1267 // velocity at or below this results in no offset at all
1268 static const float min_offset_vel = 1 * vehicles::vmiph_per_tile;
1269 // velocity at or above this results in maximal offset
1270 static const float max_offset_vel = std::min( max_offset.y, max_offset.x ) *
1272 float velocity = veh->velocity;
1273 rl_vec2d offset = veh->move_vec();
1274 if( !veh->skidding && veh->player_in_control( u ) &&
1275 std::abs( veh->cruise_velocity - veh->velocity ) < 7 * vehicles::vmiph_per_tile ) {
1276 // Use the cruise controlled velocity, but only if
1277 // it is not too different from the actual velocity.
1278 // The actual velocity changes too often (see above slowdown).
1279 // Using it makes would make the offset change far too often.
1280 offset = veh->face_vec();
1281 velocity = veh->cruise_velocity;
1282 }
1283 float rel_offset;
1284 if( std::fabs( velocity ) < min_offset_vel ) {
1285 rel_offset = 0;
1286 } else if( std::fabs( velocity ) > max_offset_vel ) {
1287 rel_offset = ( velocity > 0 ) ? 1 : -1;
1288 } else {
1289 rel_offset = ( velocity - min_offset_vel ) / ( max_offset_vel - min_offset_vel );
1290 }
1291 // Squeeze into the corners, by making the offset vector longer,
1292 // the PC is still in view as long as both offset.x and
1293 // offset.y are <= 1
1294 if( std::fabs( offset.x ) > std::fabs( offset.y ) && std::fabs( offset.x ) > 0.2 ) {
1295 offset.y /= std::fabs( offset.x );
1296 offset.x = ( offset.x > 0 ) ? +1 : -1;
1297 } else if( std::fabs( offset.y ) > 0.2 ) {
1298 offset.x /= std::fabs( offset.y );
1299 offset.y = offset.y > 0 ? +1 : -1;
1300 }
1301 offset.x *= rel_offset;
1302 offset.y *= rel_offset;
1303 offset.x *= max_offset.x;
1304 offset.y *= max_offset.y;
1305 // [ ----@---- ] sight=6
1306 // [ --@------ ] offset=2
1307 // [ -@------# ] offset=3
1308 // can see sights square in every direction, total visible area is
1309 // (2*sight+1)x(2*sight+1), but the window is only
1310 // getmaxx(w_terrain) x getmaxy(w_terrain)
1311 // The area outside of the window is maxoff (sight-getmax/2).
1312 // If that value is <= 0, the whole visible area fits the window.
1313 // don't apply the view offset at all.
1314 // If the offset is > maxoff, only apply at most maxoff, everything
1315 // above leads to invisible area in front of the car.
1316 // It will display (getmax/2+offset) squares in one direction and
1317 // (getmax/2-offset) in the opposite direction (centered on the PC).
1318 const point maxoff( ( sight * 2 + 1 - getmaxx( w_terrain ) ) / 2,
1319 ( sight * 2 + 1 - getmaxy( w_terrain ) ) / 2 );
1320 if( maxoff.x <= 0 ) {
1321 offset.x = 0;
1322 } else if( offset.x > 0 && offset.x > maxoff.x ) {
1323 offset.x = maxoff.x;
1324 } else if( offset.x < 0 && -offset.x > maxoff.x ) {
1325 offset.x = -maxoff.x;
1326 }
1327 if( maxoff.y <= 0 ) {
1328 offset.y = 0;
1329 } else if( offset.y > 0 && offset.y > maxoff.y ) {
1330 offset.y = maxoff.y;
1331 } else if( offset.y < 0 && -offset.y > maxoff.y ) {
1332 offset.y = -maxoff.y;
1333 }
1334
1335 // Turn the offset into a vector that increments the offset toward the desired position
1336 // instead of setting it there instantly, should smooth out jerkiness.
1337 const point offset_difference( -driving_view_offset + point( offset.x, offset.y ) );
1338
1339 const point offset_sign( ( offset_difference.x < 0 ) ? -1 : 1,
1340 ( offset_difference.y < 0 ) ? -1 : 1 );
1341 // Shift the current offset in the direction of the calculated offset by one tile
1342 // per draw event, but snap to calculated offset if we're close enough to avoid jitter.
1343 offset.x = ( std::abs( offset_difference.x ) > 1 ) ?
1344 ( driving_view_offset.x + offset_sign.x ) : offset.x;
1345 offset.y = ( std::abs( offset_difference.y ) > 1 ) ?
1346 ( driving_view_offset.y + offset_sign.y ) : offset.y;
1347
1348 set_driving_view_offset( point( offset.x, offset.y ) );
1349}
int posz() const override
Definition: character.h:803
int sight_range(int light_level) const override
Returns the player's sight range.
Definition: character.cpp:603
point driving_view_offset
Definition: game.h:996
catacurses::window w_terrain
Definition: game.h:986
void set_driving_view_offset(point p)
Definition: game.cpp:1608
unsigned char light_level(int zlev) const
Returns coarse number-of-squares of visibility at the current light level.
Definition: game.cpp:3558
rl_vec2d move_vec() const
rl_vec2d face_vec() const
bool skidding
Definition: vehicle.h:2024
bool player_in_control(const Character &p) const
Definition: vehicle.cpp:278
int velocity
Definition: vehicle.h:1943
int cruise_velocity
Definition: vehicle.h:1945
static int veh_lumi(vehicle &veh)
Definition: game.cpp:1233
int getmaxx(const window &win)
Definition: ncurses_def.cpp:58
int getmaxy(const window &win)
Definition: ncurses_def.cpp:63
quantity< V, U > fabs(quantity< V, U > q)
Definition: units_def.h:136
constexpr float vmiph_per_tile
Definition: vehicle.h:69
static constexpr point point_zero
Definition: point.h:260
Definition: point.h:35
int y
Definition: point.h:39
int x
Definition: point.h:38
float y
Definition: point_float.h:13
float x
Definition: point_float.h:12

References vehicle::cruise_velocity, driving_view_offset, units::fabs(), vehicle::face_vec(), catacurses::getmaxx(), catacurses::getmaxy(), light_level(), vehicle::move_vec(), vehicle::player_in_control(), point_zero, Character::posz(), set_driving_view_offset(), Character::sight_range(), vehicle::skidding, u, veh_lumi(), vehicle::velocity, vehicles::vmiph_per_tile, w_terrain, point::x, rl_vec2d::x, point::y, and rl_vec2d::y.

Referenced by do_turn().

◆ cancel_activity_or_ignore_query()

bool game::cancel_activity_or_ignore_query ( distraction_type  type,
const std::string &  text 
)

Asks if the player wants to cancel their activity and if so cancels it.

Additionally checks if the player wants to ignore further distractions.

Definition at line 1710 of file game.cpp.

1711{
1714 return false;
1715 }
1716 if( u.has_distant_destination() ) {
1717 if( cancel_auto_move( u, text ) ) {
1718 return true;
1719 } else {
1721 return false;
1722 }
1723 }
1724 const bool force_uc = get_option<bool>( "FORCE_CAPITAL_YN" );
1725 const auto &allow_key = force_uc ? input_context::disallow_lower_case
1727
1728 const auto &action = query_popup()
1729 .context( "CANCEL_ACTIVITY_OR_IGNORE_QUERY" )
1730 .message( force_uc ?
1731 pgettext( "cancel_activity_or_ignore_query",
1732 "<color_light_red>%s %s (Case Sensitive)</color>" ) :
1733 pgettext( "cancel_activity_or_ignore_query",
1734 "<color_light_red>%s %s</color>" ),
1735 text, u.activity.get_stop_phrase() )
1736 .option( "YES", allow_key )
1737 .option( "NO", allow_key )
1738 .option( "MANAGER", allow_key )
1739 .option( "IGNORE", allow_key )
1740 .query()
1741 .action;
1742
1743 if( action == "YES" ) {
1745 return true;
1746 }
1747 if( action == "IGNORE" ) {
1749 for( auto &activity : u.backlog ) {
1750 activity.ignore_distraction( type );
1751 }
1752 }
1753 if( action == "MANAGER" ) {
1756 return true;
1757 }
1758
1761
1762 return false;
1763}
void set_destination(const std::vector< tripoint > &route, const player_activity &new_destination_activity=player_activity())
void cancel_activity()
Definition: character.cpp:9214
std::vector< tripoint > & get_auto_move_route()
std::list< player_activity > backlog
Definition: character.h:1574
bool has_distant_destination() const
static const input_event_filter allow_all_keys
Definition: input.h:541
static const input_event_filter disallow_lower_case
Definition: input.h:540
bool is_distraction_ignored(distraction_type type) const
std::string get_stop_phrase() const
void ignore_distraction(distraction_type type)
UI class for displaying messages or querying player input with popups.
Definition: popup.h:39
query_popup & context(const std::string &cat)
Specify the input context.
Definition: popup.cpp:21
query_popup & option(const std::string &opt)
Specify an action as an option.
Definition: popup.cpp:28
result query()
Query until a valid action or an error happens and return the result.
Definition: popup.cpp:348
query_popup & message(const std::string &fmt, Args &&... args)
Specify the query message.
Definition: popup.h:91
@ action
Definition: dialogue.h:36
distraction_manager::distraction_manager_gui & get_distraction_manager()
static bool cancel_auto_move(player &p, const std::string &text)
Definition: game.cpp:1697
void redraw()
Invalidate the top window and redraw all invalidated windows.
Definition: ui_manager.cpp:389
void refresh_display()
Make changes made to the display visible to the user immediately.
std::string action
Definition: popup.h:68
const char * pgettext(const char *context, const char *msgid)

References action, query_popup::result::action, Character::activity, input_context::allow_all_keys, Character::backlog, Character::cancel_activity(), cancel_auto_move(), query_popup::context(), input_context::disallow_lower_case, Character::get_auto_move_route(), get_distraction_manager(), player_activity::get_stop_phrase(), Character::has_distant_destination(), player_activity::ignore_distraction(), invalidate_main_ui_adaptor(), player_activity::is_distraction_ignored(), query_popup::message(), query_popup::option(), pgettext(), query_popup::query(), ui_manager::redraw(), refresh_display(), Character::set_destination(), distraction_manager::distraction_manager_gui::show(), type, and u.

Referenced by mon_info_update(), monmove(), and process_voluntary_act_interrupt().

◆ cancel_activity_query()

bool game::cancel_activity_query ( const std::string &  text)

Asks if the player wants to cancel their activity, and if so cancels it.

Definition at line 1765 of file game.cpp.

1766{
1768 if( u.has_distant_destination() ) {
1769 if( cancel_auto_move( u, text ) ) {
1770 return true;
1771 } else {
1773 return false;
1774 }
1775 }
1776 if( !u.activity ) {
1777 return false;
1778 }
1779 if( query_yn( "%s %s", text, u.activity.get_stop_phrase() ) ) {
1783 return true;
1784 }
1785 return false;
1786}
void clear_destination()
void resume_backlog_activity()
Definition: character.cpp:9246

References Character::activity, Character::cancel_activity(), cancel_auto_move(), Character::clear_destination(), Character::get_auto_move_route(), player_activity::get_stop_phrase(), Character::has_distant_destination(), invalidate_main_ui_adaptor(), query_yn(), Character::resume_backlog_activity(), Character::set_destination(), and u.

Referenced by handle_key_blocking_activity().

◆ catch_a_monster()

void game::catch_a_monster ( monster fish,
const tripoint pos,
player p,
const time_duration catch_duration 
)

Picks and spawns a random fish from the remaining fish list when a fish is caught.

Definition at line 1683 of file game.cpp.

1685{
1686 //spawn the corpse, rotten by a part of the duration
1688 catch_duration ) ) );
1689 if( u.sees( pos ) ) {
1690 u.add_msg_if_player( m_good, _( "You caught a %s." ), fish->type->nname() );
1691 }
1692 //quietly kill the caught
1693 fish->no_corpse_quiet = true;
1694 fish->die( p );
1695}
bool sees(const tripoint &t, bool is_player=false, int range_mod=0) const override
static item make_corpse(const mtype_id &mt=string_id< mtype >::NULL_ID(), time_point turn=calendar::turn, const std::string &name="", int upgrade_time=-1)
Make a corpse of the given monster type.
Definition: item.cpp:507
item & add_item_or_charges(const tripoint &pos, item obj, bool overflow=true)
Adds an item to map tile or stacks charges.
Definition: map.cpp:4333
bool no_corpse_quiet
Definition: monster.h:482
void die(Creature *killer) override
Empty function.
Definition: monster.cpp:2292
const mtype * type
Definition: monster.h:478
void add_msg_if_player(const std::string &msg) const override
Definition: player.cpp:364
time_point turn
Definition: calendar.cpp:36
mtype_id id
Definition: mtype.h:240
std::string nname(unsigned int quantity=1) const
Definition: mtype.cpp:65

References _, map::add_item_or_charges(), player::add_msg_if_player(), monster::die(), mtype::id, m, m_good, item::make_corpse(), mtype::nname(), monster::no_corpse_quiet, rng(), Character::sees(), calendar::turn, monster::type, and u.

◆ chat()

void game::chat ( )
private

Definition at line 396 of file npctalk.cpp.

397{
398 int volume = u.get_shout_volume();
399
400 const std::vector<npc *> available = get_npcs_if( [&]( const npc & guy ) {
401 // TODO: Get rid of the z-level check when z-level vision gets "better"
402 return u.posz() == guy.posz() && u.sees( guy.pos() ) &&
403 rl_dist( u.pos(), guy.pos() ) <= SEEX * 2;
404 } );
405 const int available_count = available.size();
406 const std::vector<npc *> followers = get_npcs_if( [&]( const npc & guy ) {
407 return guy.is_player_ally() && guy.is_following() && guy.can_hear( u.pos(), volume );
408 } );
409 const int follower_count = followers.size();
410 const std::vector<npc *> guards = get_npcs_if( [&]( const npc & guy ) {
411 return guy.mission == NPC_MISSION_GUARD_ALLY &&
412 guy.companion_mission_role_id != "FACTION_CAMP" &&
413 guy.can_hear( u.pos(), volume );
414 } );
415 const int guard_count = guards.size();
416
417 if( u.has_trait( trait_PROF_FOODP ) && !( u.is_wearing( itype_id( "foodperson_mask" ) ) ||
418 u.is_wearing( itype_id( "foodperson_mask_on" ) ) ) ) {
419 u.add_msg_if_player( m_warning, _( "You can't speak without your face!" ) );
420 return;
421 }
422 std::vector<vehicle *> animal_vehicles;
423 std::vector<vehicle *> following_vehicles;
424 std::vector<vehicle *> magic_vehicles;
425 std::vector<vehicle *> magic_following_vehicles;
426 for( auto &veh : m.get_vehicles() ) {
427 auto &v = veh.v;
428 if( v->has_engine_type( fuel_type_animal, false ) && v->is_owned_by( u ) ) {
429 animal_vehicles.push_back( v );
430 if( v->is_following ) {
431 following_vehicles.push_back( v );
432 }
433 }
434 if( v->magic ) {
435 for( const vpart_reference &vp : v->get_all_parts() ) {
436 const vpart_info &vpi = vp.info();
437 if( vpi.has_flag( "MAGIC_FOLLOW" ) ) {
438 magic_vehicles.push_back( v );
439 if( v->is_following ) {
440 magic_following_vehicles.push_back( v );
441 }
442 break;
443 }
444 }
445 }
446 }
447
448 uilist nmenu;
449 nmenu.text = std::string( _( "What do you want to do?" ) );
450
451 if( !available.empty() ) {
452 nmenu.addentry( NPC_CHAT_TALK, true, 't', available_count == 1 ?
453 string_format( _( "Talk to %s" ), available.front()->name ) :
454 _( "Talk to…" )
455 );
456 }
457 nmenu.addentry( NPC_CHAT_YELL, true, 'a', _( "Yell" ) );
458 nmenu.addentry( NPC_CHAT_SENTENCE, true, 'b', _( "Yell a sentence" ) );
459 if( !animal_vehicles.empty() ) {
461 _( "Whistle at your animals pulling vehicles to follow you." ) );
462 }
463 if( !magic_vehicles.empty() ) {
465 _( "Utter a magical command that will order your magical vehicles to follow you." ) );
466 }
467 if( !magic_following_vehicles.empty() ) {
469 _( "Utter a magical command that will order your magical vehicles to stop following you." ) );
470 }
471 if( !following_vehicles.empty() ) {
473 _( "Whistle at your animals pulling vehicles to stop following you." ) );
474 }
475 if( !guards.empty() ) {
476 nmenu.addentry( NPC_CHAT_FOLLOW, true, 'f', guard_count == 1 ?
477 string_format( _( "Tell %s to follow" ), guards.front()->name ) :
478 _( "Tell someone to follow…" )
479 );
480 }
481 if( !followers.empty() ) {
482 nmenu.addentry( NPC_CHAT_GUARD, true, 'g', follower_count == 1 ?
483 string_format( _( "Tell %s to guard" ), followers.front()->name ) :
484 _( "Tell someone to guard…" )
485 );
486 nmenu.addentry( NPC_CHAT_MOVE_TO_POS, true, 'G',
487 follower_count == 1 ? string_format( _( "Tell %s to move to location" ),
488 followers.front()->get_name() ) : _( "Tell someone to move to location…" ) );
489 nmenu.addentry( NPC_CHAT_AWAKE, true, 'w', _( "Tell everyone on your team to wake up" ) );
490 nmenu.addentry( NPC_CHAT_MOUNT, true, 'M', _( "Tell everyone on your team to mount up" ) );
491 nmenu.addentry( NPC_CHAT_DISMOUNT, true, 'm', _( "Tell everyone on your team to dismount" ) );
492 nmenu.addentry( NPC_CHAT_DANGER, true, 'D',
493 _( "Tell everyone on your team to prepare for danger" ) );
494 nmenu.addentry( NPC_CHAT_CLEAR_OVERRIDES, true, 'r',
495 _( "Tell everyone on your team to relax (Clear Overrides)" ) );
496 nmenu.addentry( NPC_CHAT_ORDERS, true, 'o', _( "Tell everyone on your team to temporarily…" ) );
497 }
498 std::string message;
499 std::string yell_msg;
500 bool is_order = true;
501 nmenu.query();
502
503 if( nmenu.ret < 0 ) {
504 return;
505 }
506
507 switch( nmenu.ret ) {
508 case NPC_CHAT_TALK: {
509 const int npcselect = npc_select_menu( available, _( "Talk to whom?" ), false );
510 if( npcselect < 0 ) {
511 return;
512 }
513 available[npcselect]->talk_to_u();
514 break;
515 }
516 case NPC_CHAT_YELL:
517 is_order = false;
518 message = _( "loudly." );
519 break;
520 case NPC_CHAT_SENTENCE: {
521 std::string popupdesc = _( "Enter a sentence to yell" );
523 popup.title( _( "Yell a sentence" ) )
524 .width( 64 )
525 .description( popupdesc )
526 .identifier( "sentence" )
527 .max_length( 128 )
528 .query();
529 yell_msg = popup.text();
530 is_order = false;
531 break;
532 }
533 case NPC_CHAT_GUARD: {
534 const int npcselect = npc_select_menu( followers, _( "Who should guard here?" ) );
535 if( npcselect < 0 ) {
536 return;
537 }
538 if( npcselect == follower_count ) {
539 for( npc *them : followers ) {
541 }
542 yell_msg = _( "Everyone guard here!" );
543 } else {
544 talk_function::assign_guard( *followers[npcselect] );
545 yell_msg = string_format( _( "Guard here, %s!" ), followers[npcselect]->name );
546 }
547 break;
548 }
550 const int npcselect = npc_select_menu( followers, _( "Who should move?" ) );
551 if( npcselect < 0 ) {
552 return;
553 }
554
555 map &here = get_map();
556 std::optional<tripoint> p = look_around();
557
558 if( !p ) {
559 return;
560 }
561
562 if( here.impassable( tripoint( *p ) ) ) {
563 add_msg( m_info, _( "This destination can't be reached." ) );
564 return;
565 }
566
567 const auto &to = p.value();
568 if( npcselect == follower_count ) {
569 for( npc *them : followers ) {
570 tripoint_abs_ms( here.getabs( to ) );
571 them->goto_to_this_pos = here.getglobal( to );
572 }
573 yell_msg = _( "Everyone move there!" );
574 } else {
575 followers[npcselect]->goto_to_this_pos = here.getglobal( to );
576 yell_msg = string_format( _( "Move there, %s!" ), followers[npcselect]->get_name() );
577 }
578 break;
579 }
580 case NPC_CHAT_FOLLOW: {
581 const int npcselect = npc_select_menu( guards, _( "Who should follow you?" ) );
582 if( npcselect < 0 ) {
583 return;
584 }
585 if( npcselect == guard_count ) {
586 for( npc *them : guards ) {
588 }
589 yell_msg = _( "Everyone follow me!" );
590 } else {
591 talk_function::stop_guard( *guards[npcselect] );
592 yell_msg = string_format( _( "Follow me, %s!" ), guards[npcselect]->name );
593 }
594 break;
595 }
596 case NPC_CHAT_AWAKE:
597 for( npc *them : followers ) {
598 talk_function::wake_up( *them );
599 }
600 yell_msg = _( "Stay awake!" );
601 break;
602 case NPC_CHAT_MOUNT:
603 for( npc *them : followers ) {
604 if( them->has_effect( effect_riding ) ) {
605 continue;
606 }
608 }
609 yell_msg = _( "Mount up!" );
610 break;
612 for( npc *them : followers ) {
613 if( them->has_effect( effect_riding ) ) {
614 them->npc_dismount();
615 }
616 }
617 yell_msg = _( "Dismount!" );
618 break;
619 case NPC_CHAT_DANGER:
620 for( npc *them : followers ) {
621 them->rules.set_danger_overrides();
622 }
623 yell_msg = _( "We're in danger. Stay awake, stay close, don't go wandering off, "
624 "and don't open any doors." );
625 break;
627 for( npc *p : followers ) {
629 }
630 yell_msg = _( "As you were." );
631 break;
632 case NPC_CHAT_ORDERS:
633 npc_temp_orders_menu( followers );
634 break;
637 break;
640 break;
643 break;
646 break;
647 default:
648 return;
649 }
650
651 if( !yell_msg.empty() ) {
652 message = string_format( "\"%s\"", yell_msg );
653 }
654 if( !message.empty() ) {
655 add_msg( _( "You yell %s" ), message );
656 u.shout( string_format( _( "%s yelling %s" ), u.disp_name(), message ), is_order );
657 }
658
659 u.moves -= 100;
660}
std::string disp_name(bool possessive=false, bool capitalize_first=false) const override
Returns either "you" or the player's name.
Definition: character.cpp:577
void shout(std::string msg="", bool order=false)
Definition: character.cpp:7615
bool can_hear(const tripoint &source, int volume) const
bool is_wearing(const item &itm) const
Returns true if the player is wearing the item.
Definition: character.cpp:3224
bool has_trait(const trait_id &b) const override
Returns true if the player has the entered trait.
Definition: mutation.cpp:101
int get_shout_volume() const
Definition: character.cpp:7572
int moves
Definition: creature.h:582
std::optional< tripoint > look_around(bool force_3d=false)
Definition: game.cpp:6575
friend map & get_map()
Definition: map.cpp:147
Manage and cache data about a part of the map.
Definition: map.h:384
bool impassable(const tripoint &p) const
Definition: map.cpp:1859
tripoint_abs_ms getglobal(const tripoint &p) const
Definition: map.cpp:8383
std::string companion_mission_role_id
Definition: npc.h:1283
npc_mission mission
Definition: npc.h:1290
bool is_player_ally() const
Definition: npc.cpp:2008
bool is_following() const
Definition: npc.cpp:2039
Shows a window querying the user for input.
bool has_flag(const std::string &flag) const
Definition: veh_type.h:336
This is a wrapper over a vehicle pointer and a reference to a part of it.
coords::coord_point< tripoint, coords::origin::abs, coords::ms > tripoint_abs_ms
Definition: coordinates.h:486
int rl_dist(const coords::coord_point< Point, Origin, Scale > &loc1, const coords::coord_point< Point, Origin, Scale > &loc2)
Definition: coordinates.h:519
static constexpr int SEEX
std::string message
Definition: mapgen.cpp:411
std::string name(type dir)
Get Human readable name of a direction.
Definition: overmap.cpp:4127
void wake_up(npc &)
void find_mount(npc &)
void clear_overrides(npc &p)
void stop_guard(npc &)
void assign_guard(npc &)
quantity< int, volume_in_milliliter_tag > volume
Definition: units_volume.h:16
@ NPC_MISSION_GUARD_ALLY
Definition: npc.h:150
static const efftype_id effect_riding("riding")
static const trait_id trait_PROF_FOODP("PROF_FOODP")
static int npc_select_menu(const std::vector< npc * > &npc_list, const std::string &prompt, const bool everyone=true)
Definition: npctalk.cpp:222
static void tell_magic_veh_stop_following()
Definition: npctalk.cpp:379
static void tell_veh_stop_following()
Definition: npctalk.cpp:342
static void assign_veh_to_follow()
Definition: npctalk.cpp:353
static void npc_temp_orders_menu(const std::vector< npc * > &npc_list)
Definition: npctalk.cpp:254
static const itype_id fuel_type_animal("animal")
@ NPC_CHAT_MOUNT
Definition: npctalk.cpp:202
@ NPC_CHAT_COMMAND_MAGIC_VEHICLE_STOP_FOLLOW
Definition: npctalk.cpp:216
@ NPC_CHAT_YELL
Definition: npctalk.cpp:196
@ NPC_CHAT_FOLLOW
Definition: npctalk.cpp:199
@ NPC_CHAT_GUARD
Definition: npctalk.cpp:198
@ NPC_CHAT_DISMOUNT
Definition: npctalk.cpp:203
@ NPC_CHAT_ANIMAL_VEHICLE_FOLLOW
Definition: npctalk.cpp:213
@ NPC_CHAT_ORDERS
Definition: npctalk.cpp:205
@ NPC_CHAT_SENTENCE
Definition: npctalk.cpp:197
@ NPC_CHAT_CLEAR_OVERRIDES
Definition: npctalk.cpp:212
@ NPC_CHAT_DANGER
Definition: npctalk.cpp:204
@ NPC_CHAT_MOVE_TO_POS
Definition: npctalk.cpp:200
@ NPC_CHAT_AWAKE
Definition: npctalk.cpp:201
@ NPC_CHAT_ANIMAL_VEHICLE_STOP_FOLLOW
Definition: npctalk.cpp:214
@ NPC_CHAT_TALK
Definition: npctalk.cpp:195
@ NPC_CHAT_COMMAND_MAGIC_VEHICLE_FOLLOW
Definition: npctalk.cpp:215
static void tell_magic_veh_to_follow()
Definition: npctalk.cpp:363
int popup(const std::string &text, PopupFlags flags)
Definition: output.cpp:764

References _, add_msg(), player::add_msg_if_player(), uilist::addentry(), talk_function::assign_guard(), assign_veh_to_follow(), available, Character::can_hear(), talk_function::clear_overrides(), npc::companion_mission_role_id, Character::disp_name(), effect_riding, talk_function::find_mount(), fuel_type_animal, get_map, get_npcs_if(), Character::get_shout_volume(), map::get_vehicles(), map::getabs(), map::getglobal(), vpart_info::has_flag(), Character::has_trait(), map::impassable(), npc::is_following(), npc::is_player_ally(), Character::is_wearing(), look_around(), m, m_info, m_warning, mapgen_defer::message, npc::mission, Creature::moves, om_direction::name(), NPC_CHAT_ANIMAL_VEHICLE_FOLLOW, NPC_CHAT_ANIMAL_VEHICLE_STOP_FOLLOW, NPC_CHAT_AWAKE, NPC_CHAT_CLEAR_OVERRIDES, NPC_CHAT_COMMAND_MAGIC_VEHICLE_FOLLOW, NPC_CHAT_COMMAND_MAGIC_VEHICLE_STOP_FOLLOW, NPC_CHAT_DANGER, NPC_CHAT_DISMOUNT, NPC_CHAT_FOLLOW, NPC_CHAT_GUARD, NPC_CHAT_MOUNT, NPC_CHAT_MOVE_TO_POS, NPC_CHAT_ORDERS, NPC_CHAT_SENTENCE, NPC_CHAT_TALK, NPC_CHAT_YELL, NPC_MISSION_GUARD_ALLY, npc_select_menu(), npc_temp_orders_menu(), popup(), Character::pos(), Character::posz(), uilist::query(), uilist::ret, rl_dist(), Character::sees(), SEEX, Character::shout(), talk_function::stop_guard(), string_format(), tell_magic_veh_stop_following(), tell_magic_veh_to_follow(), tell_veh_stop_following(), uilist::text, trait_PROF_FOODP, u, and talk_function::wake_up().

Referenced by handle_action().

◆ check_near_zone()

bool game::check_near_zone ( const zone_type_id type,
const tripoint where 
) const

Checks whether or not there is a zone of particular type nearby.

Definition at line 6025 of file game.cpp.

6026{
6027 return zone_manager::get_manager().has_near( type, m.getabs( where ) );
6028}
static zone_manager & get_manager()
Definition: clzones.cpp:126
bool has_near(const zone_type_id &type, const tripoint &where, int range=MAX_DISTANCE, const faction_id &fac=your_fac) const
Definition: clzones.cpp:702

References zone_manager::get_manager(), map::getabs(), zone_manager::has_near(), m, and type.

◆ check_safe_mode_allowed()

bool game::check_safe_mode_allowed ( bool  repeat_safe_mode_warnings = true)

Check whether movement is allowed according to safe mode settings.

Returns
true if the movement is allowed, otherwise false.

Definition at line 8565 of file game.cpp.

8566{
8567 if( !repeat_safe_mode_warnings && safe_mode_warning_logged ) {
8568 // Already warned player since safe_mode_warning_logged is set.
8569 return false;
8570 }
8571
8572 std::string msg_ignore = press_x( ACTION_IGNORE_ENEMY );
8573 if( !msg_ignore.empty() ) {
8574 std::wstring msg_ignore_wide = utf8_to_wstr( msg_ignore );
8575 // Operate on a wide-char basis to prevent corrupted multi-byte string
8576 msg_ignore_wide[0] = towlower( msg_ignore_wide[0] );
8577 msg_ignore = wstr_to_utf8( msg_ignore_wide );
8578 }
8579
8581 // Automatic and mandatory safemode. Make BLOODY sure the player notices!
8582 if( u.get_int_base() < 5 || u.has_trait( trait_id( "PROF_CHURL" ) ) ) {
8584 _( "There's an angry red dot on your body, %s to brush it off." ), msg_ignore );
8585 } else {
8587 _( "You are being laser-targeted, %s to ignore." ), msg_ignore );
8588 }
8590 return false;
8591 }
8592 if( safe_mode != SAFE_MODE_STOP ) {
8593 return true;
8594 }
8595 // Currently driving around, ignore the monster, they have no chance against a proper car anyway (-:
8596 if( u.controlling_vehicle && !get_option<bool>( "SAFEMODEVEH" ) ) {
8597 return true;
8598 }
8599 // Monsters around and we don't want to run
8600 std::string spotted_creature_name;
8601 const monster_visible_info &mon_visible = u.get_mon_visible();
8602 const auto &new_seen_mon = mon_visible.new_seen_mon;
8603
8604 if( new_seen_mon.empty() ) {
8605 // naming consistent with code in game::mon_info
8606 spotted_creature_name = _( "a survivor" );
8608 } else {
8609 spotted_creature_name = new_seen_mon.back()->name();
8610 get_safemode().lastmon_whitelist = spotted_creature_name;
8611 }
8612
8613 std::string whitelist;
8614 if( !get_safemode().empty() ) {
8615 whitelist = string_format( _( " or %s to whitelist the monster" ),
8617 }
8618
8619 const std::string msg_safe_mode = press_x( ACTION_TOGGLE_SAFEMODE );
8621 _( "Spotted %1$s--safe mode is on! (%2$s to turn it off, %3$s to ignore monster%4$s)" ),
8622 spotted_creature_name, msg_safe_mode, msg_ignore, whitelist );
8624 return false;
8625}
std::string press_x(action_id act)
Definition: action.cpp:457
@ ACTION_IGNORE_ENEMY
Ignore the enemy that triggered safemode.
Definition: action.h:217
@ ACTION_WHITELIST_ENEMY
Whitelist the enemy that triggered safemode.
Definition: action.h:219
@ ACTION_TOGGLE_SAFEMODE
Turn safemode on/off, while leaving autosafemode intact.
Definition: action.h:211
std::wstring utf8_to_wstr(const std::string &str)
std::string wstr_to_utf8(const std::wstring &wstr)
bool has_effect(const efftype_id &eff_id, body_part bp=num_bp) const
Check if creature has the matching effect.
Definition: creature.cpp:1187
int get_int_base() const override
Definition: avatar.cpp:1022
monster_visible_info & get_mon_visible()
Definition: avatar.h:226
std::string lastmon_whitelist
Definition: safemode_ui.h:87
std::string npc_type_name()
Definition: safemode_ui.cpp:44
@ gmf_bypass_cooldown
Definition: enums.h:288
static const efftype_id effect_laserlocked("laserlocked")
@ SAFE_MODE_STOP
Definition: game.h:79
safemode & get_safemode()
Definition: safemode_ui.cpp:33
Structure allowing a combination of game_message_type and game_message_flags.
Definition: enums.h:293
std::vector< shared_ptr_fast< monster > > new_seen_mon
Definition: avatar.h:41

References _, ACTION_IGNORE_ENEMY, ACTION_TOGGLE_SAFEMODE, ACTION_WHITELIST_ENEMY, add_msg(), Character::controlling_vehicle, effect_laserlocked, avatar::get_int_base(), avatar::get_mon_visible(), get_safemode(), gmf_bypass_cooldown, Creature::has_effect(), Character::has_trait(), safemode::lastmon_whitelist, m_warning, monster_visible_info::new_seen_mon, safemode::npc_type_name(), press_x(), safe_mode, SAFE_MODE_STOP, safe_mode_warning_logged, string_format(), u, utf8_to_wstr(), and wstr_to_utf8().

Referenced by handle_action().

◆ check_zone()

bool game::check_zone ( const zone_type_id type,
const tripoint where 
) const

Definition at line 6020 of file game.cpp.

6021{
6022 return zone_manager::get_manager().has( type, m.getabs( where ) );
6023}
bool has(const zone_type_id &type, const tripoint &where, const faction_id &fac=your_fac) const
Definition: clzones.cpp:694

References zone_manager::get_manager(), map::getabs(), zone_manager::has(), m, and type.

Referenced by place_player().

◆ cleanup_at_end()

bool game::cleanup_at_end ( )

Definition at line 947 of file game.cpp.

948{
949 if( uquit == QUIT_DIED || uquit == QUIT_SUICIDE ) {
950 // Put (non-hallucinations) into the overmap so they are not lost.
951 for( monster &critter : all_monsters() ) {
952 despawn_monster( critter );
953 }
954 // Reset NPC factions and disposition
956 // Save the factions', missions and set the NPC's overmap coordinates
957 // Npcs are saved in the overmap.
958 save_factions_missions_npcs(); //missions need to be saved as they are global for all saves.
959 // save artifacts.
961
962 // and the overmap, and the local map.
963 save_maps(); //Omap also contains the npcs who need to be saved.
964 }
965
966 if( uquit == QUIT_DIED || uquit == QUIT_SUICIDE ) {
967 std::vector<std::string> vRip;
968
969 int iMaxWidth = 0;
970 int iNameLine = 0;
971 int iInfoLine = 0;
972
975 if( !( u.has_trait( trait_id( "CANNIBAL" ) ) || u.has_trait( trait_id( "PSYCHOPATH" ) ) ) ) {
976 vRip.emplace_back( " _______ ___" );
977 vRip.emplace_back( " < `/ |" );
978 vRip.emplace_back( " > _ _ (" );
979 vRip.emplace_back( " | |_) | |_) |" );
980 vRip.emplace_back( " | | \\ | | |" );
981 vRip.emplace_back( " ______.__%_| |_________ __" );
982 vRip.emplace_back( " _/ \\| |" );
983 iNameLine = vRip.size();
984 vRip.emplace_back( "| <" );
985 vRip.emplace_back( "| |" );
986 iMaxWidth = utf8_width( vRip.back() );
987 vRip.emplace_back( "| |" );
988 vRip.emplace_back( "|_____.-._____ __/|_________|" );
989 vRip.emplace_back( " | |" );
990 iInfoLine = vRip.size();
991 vRip.emplace_back( " | |" );
992 vRip.emplace_back( " | <" );
993 vRip.emplace_back( " | |" );
994 vRip.emplace_back( " | _ |" );
995 vRip.emplace_back( " |__/ |" );
996 vRip.emplace_back( " % / `--. |%" );
997 vRip.emplace_back( " * .%%| -< @%%%" ); // NOLINT(cata-text-style)
998 vRip.emplace_back( " `\\%`@| |@@%@%%" );
999 vRip.emplace_back( " .%%%@@@|% ` % @@@%%@%%%%" );
1000 vRip.emplace_back( " _.%%%%%%@@@@@@%%%__/\\%@@%%@@@@@@@%%%%%%" );
1001
1002 } else {
1003 vRip.emplace_back( " _______ ___" );
1004 vRip.emplace_back( " | \\/ |" );
1005 vRip.emplace_back( " | |" );
1006 vRip.emplace_back( " | |" );
1007 iInfoLine = vRip.size();
1008 vRip.emplace_back( " | |" );
1009 vRip.emplace_back( " | |" );
1010 vRip.emplace_back( " | |" );
1011 vRip.emplace_back( " | |" );
1012 vRip.emplace_back( " | <" );
1013 vRip.emplace_back( " | _ |" );
1014 vRip.emplace_back( " |__/ |" );
1015 vRip.emplace_back( " ______.__%_| |__________ _" );
1016 vRip.emplace_back( " _/ \\| \\" );
1017 iNameLine = vRip.size();
1018 vRip.emplace_back( "| <" );
1019 vRip.emplace_back( "| |" );
1020 iMaxWidth = utf8_width( vRip.back() );
1021 vRip.emplace_back( "| |" );
1022 vRip.emplace_back( "|_____.-._______ __/|__________|" );
1023 vRip.emplace_back( " % / `_-. _ |%" );
1024 vRip.emplace_back( " * .%%| |_) | |_)< @%%%" ); // NOLINT(cata-text-style)
1025 vRip.emplace_back( " `\\%`@| | \\ | | |@@%@%%" );
1026 vRip.emplace_back( " .%%%@@@|% ` % @@@%%@%%%%" );
1027 vRip.emplace_back( " _.%%%%%%@@@@@@%%%__/\\%@@%%@@@@@@@%%%%%%" );
1028 }
1029 } else {
1030 vRip.emplace_back( R"( _________ ____ )" );
1031 vRip.emplace_back( R"( _/ `/ \_ )" );
1032 vRip.emplace_back( R"( _/ _ _ \_. )" );
1033 vRip.emplace_back( R"( _%\ |_) | |_) \_ )" );
1034 vRip.emplace_back( R"( _/ \/ | \ | | \_ )" );
1035 vRip.emplace_back( R"( _/ \_ )" );
1036 vRip.emplace_back( R"(| |)" );
1037 iNameLine = vRip.size();
1038 vRip.emplace_back( R"( ) < )" );
1039 vRip.emplace_back( R"(| |)" );
1040 vRip.emplace_back( R"(| |)" );
1041 vRip.emplace_back( R"(| _ |)" );
1042 vRip.emplace_back( R"(|__/ |)" );
1043 iMaxWidth = utf8_width( vRip.back() );
1044 vRip.emplace_back( R"( / `--. |)" );
1045 vRip.emplace_back( R"(| ( )" );
1046 iInfoLine = vRip.size();
1047 vRip.emplace_back( R"(| |)" );
1048 vRip.emplace_back( R"(| |)" );
1049 vRip.emplace_back( R"(| % . |)" );
1050 vRip.emplace_back( R"(| @` %% |)" );
1051 vRip.emplace_back( R"(| %@%@%\ * %`%@%|)" );
1052 vRip.emplace_back( R"(%%@@@.%@%\%% `\ %%.%%@@%@)" );
1053 vRip.emplace_back( R"(@%@@%%%%%@@@@@@%%%%%%%%@@%%@@@%%%@%%@)" );
1054 }
1055
1056 const int iOffsetX = TERMX > FULL_SCREEN_WIDTH ? ( TERMX - FULL_SCREEN_WIDTH ) / 2 : 0;
1057 const int iOffsetY = TERMY > FULL_SCREEN_HEIGHT ? ( TERMY - FULL_SCREEN_HEIGHT ) / 2 : 0;
1058
1060 point( iOffsetX, iOffsetY ) );
1061 draw_border( w_rip );
1062
1063 sfx::do_player_death_hurt( g->u, true );
1068
1069 for( size_t iY = 0; iY < vRip.size(); ++iY ) {
1070 size_t iX = 0;
1071 const char *str = vRip[iY].data();
1072 for( int slen = vRip[iY].size(); slen > 0; ) {
1073 const uint32_t cTemp = UTF8_getch( &str, &slen );
1074 if( cTemp != U' ' ) {
1075 nc_color ncColor = c_light_gray;
1076
1077 if( cTemp == U'%' ) {
1078 ncColor = c_green;
1079
1080 } else if( cTemp == U'_' || cTemp == U'|' ) {
1081 ncColor = c_white;
1082
1083 } else if( cTemp == U'@' ) {
1084 ncColor = c_brown;
1085
1086 } else if( cTemp == U'*' ) {
1087 ncColor = c_red;
1088 }
1089
1090 mvwputch( w_rip, point( iX + FULL_SCREEN_WIDTH / 2 - ( iMaxWidth / 2 ), iY + 1 ), ncColor,
1091 cTemp );
1092 }
1093 iX += mk_wcwidth( cTemp );
1094 }
1095 }
1096
1097 std::string sTemp;
1098
1099 center_print( w_rip, iInfoLine++, c_white, _( "Survived:" ) );
1100
1102 const int minutes = to_minutes<int>( survived ) % 60;
1103 const int hours = to_hours<int>( survived ) % 24;
1104 const int days = to_days<int>( survived );
1105
1106 if( days > 0 ) {
1107 sTemp = string_format( "%dd %dh %dm", days, hours, minutes );
1108 } else if( hours > 0 ) {
1109 sTemp = string_format( "%dh %dm", hours, minutes );
1110 } else {
1111 sTemp = string_format( "%dm", minutes );
1112 }
1113
1114 center_print( w_rip, iInfoLine++, c_white, sTemp );
1115
1116 const int iTotalKills = get_kill_tracker().monster_kill_count();
1117
1118 sTemp = _( "Kills:" );
1119 mvwprintz( w_rip, point( FULL_SCREEN_WIDTH / 2 - 5, 1 + iInfoLine++ ), c_light_gray,
1120 ( sTemp + " " ) );
1121 wprintz( w_rip, c_magenta, "%d", iTotalKills );
1122
1123 sTemp = _( "In memory of:" );
1124 mvwprintz( w_rip, point( FULL_SCREEN_WIDTH / 2 - utf8_width( sTemp ) / 2, iNameLine++ ),
1126 sTemp );
1127
1128 sTemp = u.name;
1129 mvwprintz( w_rip, point( FULL_SCREEN_WIDTH / 2 - utf8_width( sTemp ) / 2, iNameLine++ ), c_white,
1130 sTemp );
1131
1132 sTemp = _( "Last Words:" );
1133 mvwprintz( w_rip, point( FULL_SCREEN_WIDTH / 2 - utf8_width( sTemp ) / 2, iNameLine++ ),
1135 sTemp );
1136
1137 int iStartX = FULL_SCREEN_WIDTH / 2 - ( ( iMaxWidth - 4 ) / 2 );
1138 std::string sLastWords = string_input_popup()
1139 .window( w_rip, point( iStartX, iNameLine ), iStartX + iMaxWidth - 4 - 1 )
1140 .max_length( iMaxWidth - 4 - 1 )
1141 .query_string();
1142 death_screen();
1143 const bool is_suicide = uquit == QUIT_SUICIDE;
1144 events().send<event_type::game_over>( is_suicide, sLastWords );
1145 // Struck the save_player_data here to forestall Weirdness
1146 std::string char_filename = generate_memorial_filename( u.name );
1147 move_save_to_graveyard( char_filename );
1148 write_memorial_file( char_filename, sLastWords );
1149 memorial().clear();
1150 std::vector<std::string> characters = list_active_saves();
1151 // remove current player from the active characters list, as they are dead
1152 std::vector<std::string>::iterator curchar = std::find( characters.begin(),
1153 characters.end(), u.get_save_id() );
1154 if( curchar != characters.end() ) {
1155 characters.erase( curchar );
1156 }
1157
1158 if( characters.empty() ) {
1159 bool queryDelete = false;
1160 bool queryReset = false;
1161
1162 if( get_option<std::string>( "WORLD_END" ) == "query" ) {
1163 bool decided = false;
1164 std::string buffer = _( "Warning: NPC interactions and some other global flags "
1165 "will not all reset when starting a new character in an "
1166 "already-played world. This can lead to some strange "
1167 "behavior.\n\n"
1168 "Are you sure you wish to keep this world?"
1169 );
1170
1171 while( !decided ) {
1172 uilist smenu;
1173 smenu.allow_cancel = false;
1174 smenu.addentry( 0, true, 'r', "%s", _( "Reset world" ) );
1175 smenu.addentry( 1, true, 'd', "%s", _( "Delete world" ) );
1176 smenu.addentry( 2, true, 'k', "%s", _( "Keep world" ) );
1177 smenu.query();
1178
1179 switch( smenu.ret ) {
1180 case 0:
1181 queryReset = true;
1182 decided = true;
1183 break;
1184 case 1:
1185 queryDelete = true;
1186 decided = true;
1187 break;
1188 case 2:
1189 decided = query_yn( buffer );
1190 break;
1191 }
1192 }
1193 }
1194
1195 if( queryDelete || get_option<std::string>( "WORLD_END" ) == "delete" ) {
1196 world_generator->delete_world( world_generator->active_world->world_name, true );
1197
1198 } else if( queryReset || get_option<std::string>( "WORLD_END" ) == "reset" ) {
1199 world_generator->delete_world( world_generator->active_world->world_name, false );
1200 }
1201 } else if( get_option<std::string>( "WORLD_END" ) != "keep" ) {
1202 std::string tmpmessage;
1203 for( auto &character : characters ) {
1204 tmpmessage += "\n ";
1205 tmpmessage += character;
1206 }
1207 popup( _( "World retained. Characters remaining:%s" ), tmpmessage );
1208 }
1209 if( gamemode ) {
1210 gamemode = std::make_unique<special_game>(); // null gamemode or something..
1211 }
1212 }
1213
1214 //Reset any offset due to driving
1216
1217 //clear all sound channels
1223
1224 MAPBUFFER.clear();
1226
1227#if defined(__ANDROID__)
1228 quick_shortcuts_map.clear();
1229#endif
1230 return true;
1231}
uint32_t UTF8_getch(const char **src, int *srclen)
Definition: catacharset.cpp:18
int utf8_width(const char *s, const bool ignore_tags)
std::string name
Definition: character.h:1561
std::string get_save_id() const
Definition: avatar.h:88
A wrapper over a pointer to a curses window.
Definition: cursesdef.h:55
void send(const cata::event &) const
Definition: event_bus.cpp:58
void move_save_to_graveyard(const std::string &dirname)
Definition: game.cpp:2479
bool save_maps()
Definition: game.cpp:2678
std::unique_ptr< special_game > gamemode
Definition: game.h:1054
void death_screen()
Definition: game.cpp:2428
monster_range all_monsters()
Same as all_creatures but iterators only over monsters.
Definition: game.cpp:12001
bool save_factions_missions_npcs()
Definition: game.cpp:2664
void despawn_monster(monster &critter)
Despawn a specific monster, it's stored on the overmap.
Definition: game.cpp:11010
const kill_tracker & get_kill_tracker() const
Definition: game.cpp:886
void write_memorial_file(const std::string &filename, std::string sLastWords)
Writes information about the character out to a text file timestamped with the time of the file was m...
Definition: game.cpp:2780
std::vector< std::string > list_active_saves()
Returns a list of currently active character saves.
Definition: game.cpp:2765
bool save_artifacts()
Definition: game.cpp:2672
memorial_logger & memorial()
Definition: game.cpp:2727
void reset_npc_dispositions()
Definition: game.cpp:2636
int monster_kill_count() const
void clear()
Delete all buffered submaps.
Definition: mapbuffer.cpp:45
string_input_popup & window(const catacurses::window &w, point start, int endx)
Set the window area where to display the input text.
string_input_popup & max_length(int value)
Maximal amount of Unicode characters that can be given by the user.
const std::string & query_string(bool loop=true, bool draw_only=false)
A duration defined as a number of specific time units.
Definition: calendar.h:180
bool allow_cancel
Definition: ui.h:362
bool has_amount(const itype_id &what, int qty, bool pseudo=true, const std::function< bool(const item &)> &filter=return_true< item >) const
Check instance provides at least qty of an item (.
Definition: visitable.cpp:1109
#define c_white
Definition: color.h:18
#define c_light_gray
Definition: color.h:19
#define c_green
Definition: color.h:22
#define c_magenta
Definition: color.h:25
#define c_brown
Definition: color.h:26
#define c_red
Definition: color.h:21
static const itype_id itype_holybook_bible1("holybook_bible1")
static std::string generate_memorial_filename(const std::string &char_name)
Definition: game.cpp:920
static const itype_id itype_holybook_bible2("holybook_bible2")
static const itype_id itype_holybook_bible3("holybook_bible3")
std::unique_ptr< game > g
Definition: game.cpp:283
@ QUIT_DIED
Definition: game.h:72
@ QUIT_SUICIDE
Definition: game.h:69
const time_point & start_of_cataclysm
Definition: calendar.cpp:33
window newwin(int nlines, int ncols, point begin)
Definition: ncurses_def.cpp:34
FMT_CONSTEXPR bool find(Ptr first, Ptr last, T value, Ptr &out)
const size_t size
Definition: om_direction.h:28
void do_player_death_hurt(const player &target, bool death)
Definition: sounds.cpp:1631
void fade_audio_channel(channel channel, int duration)
Definition: sounds.cpp:1616
void fade_audio_group(group group, int duration)
Definition: sounds.cpp:1615
int TERMX
Definition: output.cpp:47
void mvwprintz(const catacurses::window &w, point p, const nc_color &FG, const std::string &text)
Definition: output.cpp:2081
int FULL_SCREEN_HEIGHT
Definition: output.cpp:56
int TERMY
Definition: output.cpp:48
void center_print(const catacurses::window &w, const int y, const nc_color &FG, const std::string &text)
Definition: output.cpp:446
void mvwputch(const catacurses::window &w, point p, nc_color FG, int ch)
Definition: output.cpp:477
void wprintz(const catacurses::window &w, const nc_color &FG, const std::string &text)
Definition: output.cpp:2089
int FULL_SCREEN_WIDTH
Definition: output.cpp:55
void draw_border(const catacurses::window &w, nc_color border_color, const std::string &title, nc_color title_color)
Definition: output.cpp:575
overmapbuffer overmap_buffer
int mk_wcwidth(uint32_t ucs)
Definition: wcwidth.cpp:94

References _, uilist::addentry(), all_monsters(), uilist::allow_cancel, sfx::any, c_brown, c_green, c_light_gray, c_magenta, c_red, c_white, center_print(), mapbuffer::clear(), memorial_logger::clear(), overmapbuffer::clear(), sfx::context_themes, death_screen(), despawn_monster(), sfx::do_player_death_hurt(), draw_border(), events(), sfx::fade_audio_channel(), sfx::fade_audio_group(), sfx::fatigue, detail::find(), FULL_SCREEN_HEIGHT, FULL_SCREEN_WIDTH, g, game_over, gamemode, generate_memorial_filename(), get_kill_tracker(), avatar::get_save_id(), visitable< T >::has_amount(), Character::has_trait(), itype_holybook_bible1, itype_holybook_bible2, itype_holybook_bible3, list_active_saves(), MAPBUFFER, string_input_popup::max_length(), memorial(), mk_wcwidth(), kill_tracker::monster_kill_count(), move_save_to_graveyard(), mvwprintz(), mvwputch(), Character::name, catacurses::newwin(), overmap_buffer, point_zero, popup(), uilist::query(), string_input_popup::query_string(), query_yn(), QUIT_DIED, QUIT_SUICIDE, reset_npc_dispositions(), uilist::ret, save_artifacts(), save_factions_missions_npcs(), save_maps(), event_bus::send(), set_driving_view_offset(), om_direction::size, calendar::start_of_cataclysm, string_format(), TERMX, TERMY, sfx::time_of_day, calendar::turn, u, uquit, UTF8_getch(), utf8_width(), sfx::weather, string_input_popup::window(), world_generator, wprintz(), and write_memorial_file().

Referenced by do_turn().

◆ cleanup_dead()

void game::cleanup_dead ( )

Definition at line 4034 of file game.cpp.

4035{
4036 // Dead monsters need to stay in the tracker until everything else that needs to die does so
4037 // This is because dying monsters can still interact with other dying monsters (@ref Creature::killer)
4038 bool monster_is_dead = critter_tracker->kill_marked_for_death();
4039
4040 bool npc_is_dead = false;
4041 // can't use all_npcs as that does not include dead ones
4042 for( const auto &n : active_npc ) {
4043 if( n->is_dead() ) {
4044 n->die( nullptr ); // make sure this has been called to create corpses etc.
4045 npc_is_dead = true;
4046 }
4047 }
4048
4049 if( monster_is_dead ) {
4050 // From here on, pointers to creatures get invalidated as dead creatures get removed.
4051 critter_tracker->remove_dead();
4052 }
4053
4054 if( npc_is_dead ) {
4055 for( auto it = active_npc.begin(); it != active_npc.end(); ) {
4056 if( ( *it )->is_dead() ) {
4057 remove_npc_follower( ( *it )->getID() );
4058 overmap_buffer.remove_npc( ( *it )->getID() );
4059 it = active_npc.erase( it );
4060 } else {
4061 it++;
4062 }
4063 }
4064 }
4065
4066 critter_died = false;
4067}
void remove_npc_follower(const character_id &id)
Remove follower id from follower set.
Definition: game.cpp:1890
pimpl< Creature_tracker > critter_tracker
Definition: game.h:972
std::list< shared_ptr_fast< npc > > active_npc
Definition: game.h:1036
bool critter_died
Has anything died in this turn and needs to be cleaned up?
Definition: game.h:1048
shared_ptr_fast< npc > remove_npc(const character_id &id)
Find npc by id and if found, erase it from the npc list and return it ( or return nullptr if not foun...

References active_npc, critter_died, critter_tracker, overmap_buffer, overmapbuffer::remove_npc(), and remove_npc_follower().

Referenced by do_turn(), and monmove().

◆ clear_zombies()

void game::clear_zombies ( )

Redirects to the creature_tracker clear() function.

Definition at line 4730 of file game.cpp.

4731{
4732 critter_tracker->clear();
4733}

References critter_tracker.

Referenced by setup().

◆ control_vehicle()

void game::control_vehicle ( )
private

Definition at line 5174 of file game.cpp.

5175{
5176 static const itype_id fuel_type_animal( "animal" );
5177 int veh_part = -1;
5178 vehicle *veh = remoteveh();
5179 if( veh == nullptr ) {
5180 if( const optional_vpart_position vp = m.veh_at( u.pos() ) ) {
5181 veh = &vp->vehicle();
5182 veh_part = vp->part_index();
5183 }
5184 }
5185 if( veh != nullptr && veh->player_in_control( u ) &&
5186 veh->avail_part_with_feature( veh_part, "CONTROLS", true ) >= 0 ) {
5187 veh->use_controls( u.pos() );
5188 } else if( veh && veh->player_in_control( u ) &&
5189 veh->avail_part_with_feature( veh_part, "CONTROL_ANIMAL", true ) >= 0 ) {
5190 u.controlling_vehicle = false;
5191 add_msg( m_info, _( "You let go of the reins." ) );
5192 } else if( veh && ( veh->avail_part_with_feature( veh_part, "CONTROLS", true ) >= 0 ||
5193 ( veh->avail_part_with_feature( veh_part, "CONTROL_ANIMAL", true ) >= 0 &&
5194 veh->has_engine_type( fuel_type_animal, false ) && veh->has_harnessed_animal() ) ) &&
5195 u.in_vehicle ) {
5196 if( u.has_trait( trait_WAYFARER ) ) {
5197 add_msg( m_info, _( "You refuse to take control of this vehicle." ) );
5198 return;
5199 }
5200 if( !veh->interact_vehicle_locked() ) {
5201 veh->handle_potential_theft( u );
5202 return;
5203 }
5204 if( veh->engine_on ) {
5205 if( !veh->handle_potential_theft( u ) ) {
5206 return;
5207 }
5208 u.controlling_vehicle = true;
5209 add_msg( _( "You take control of the %s." ), veh->name );
5210 } else {
5211 if( !veh->handle_potential_theft( u ) ) {
5212 return;
5213 }
5214 veh->start_engines( true );
5215 }
5216 } else { // Start looking for nearby vehicle controls.
5217 int num_valid_controls = 0;
5218 std::optional<tripoint> vehicle_position;
5219 std::optional<vpart_reference> vehicle_controls;
5220 for( const tripoint elem : m.points_in_radius( g->u.pos(), 1 ) ) {
5221 if( const optional_vpart_position vp = m.veh_at( elem ) ) {
5222 const std::optional<vpart_reference> controls = vp.value().part_with_feature( "CONTROLS", true );
5223 if( controls ) {
5224 num_valid_controls++;
5225 vehicle_position = elem;
5226 vehicle_controls = controls;
5227 }
5228 }
5229 }
5230 if( num_valid_controls < 1 ) {
5231 add_msg( _( "No vehicle controls found." ) );
5232 return;
5233 } else if( num_valid_controls > 1 ) {
5234 vehicle_position = choose_adjacent( _( "Control vehicle where?" ) );
5235 if( !vehicle_position ) {
5236 return;
5237 }
5238 const optional_vpart_position vp = m.veh_at( *vehicle_position );
5239 if( vp ) {
5240 vehicle_controls = vp.value().part_with_feature( "CONTROLS", true );
5241 if( !vehicle_controls ) {
5242 add_msg( _( "The vehicle doesn't have controls there." ) );
5243 return;
5244 }
5245 } else {
5246 add_msg( _( "No vehicle there." ) );
5247 return;
5248 }
5249 }
5250 // If we hit neither of those, there's only one set of vehicle controls, which should already have been found.
5251 if( vehicle_controls ) {
5252 veh = &vehicle_controls->vehicle();
5253 if( !veh->handle_potential_theft( u ) ) {
5254 return;
5255 }
5256 veh->use_controls( *vehicle_position );
5257 //May be folded up (destroyed), so need to re-get it
5258 veh = g->remoteveh();
5259 }
5260 }
5261 if( veh ) {
5262 // If we reached here, we gained control of a vehicle.
5263 // Clear the map memory for the area covered by the vehicle to eliminate ghost vehicles.
5264 for( const tripoint &target : veh->get_points() ) {
5265 u.clear_memorized_tile( m.getabs( target ) );
5266 }
5267 veh->is_following = false;
5268 veh->is_patrolling = false;
5269 veh->autopilot_on = false;
5270 veh->is_autodriving = false;
5271 }
5272}
std::optional< tripoint > choose_adjacent(const std::string &message, const bool allow_vertical)
Request player input of adjacent tile, possibly including vertical tiles.
Definition: action.cpp:979
bool in_vehicle
Definition: character.h:1568
void clear_memorized_tile(const tripoint &pos)
Definition: avatar.cpp:168
vehicle * remoteveh()
Returns the current remotely controlled vehicle.
Definition: game.cpp:2258
tripoint_range< tripoint > points_in_radius(const tripoint &center, size_t radius, size_t radiusz=0) const
Definition: map.cpp:8733
optional_vpart_position veh_at(const tripoint &p) const
Checks if tile is occupied by vehicle and by which part.
Definition: map.cpp:1073
Simple wrapper to forward functions that may return a std::optional to vpart_position.
std::optional< vpart_reference > part_with_feature(const std::string &f, bool unbroken) const
Definition: vehicle.cpp:2482
bool engine_on
Definition: vehicle.h:2014
std::set< tripoint > & get_points(bool force_refresh=false)
Definition: vehicle.cpp:6762
std::string name
Definition: vehicle.h:1874
bool has_engine_type(const itype_id &ft, bool enabled) const
Definition: vehicle.cpp:1032
void start_engines(bool take_control=false, bool autodrive=false)
void use_controls(const tripoint &pos)
Operate vehicle controls.
vehicle(const vproto_id &type_id, int init_veh_fuel=-1, int init_veh_status=-1)
Definition: vehicle.cpp:252
bool has_harnessed_animal() const
bool interact_vehicle_locked()
int avail_part_with_feature(int p, const std::string &f, bool unbroken) const
Definition: vehicle.cpp:2546
bool autopilot_on
Definition: vehicle.h:2022
bool is_autodriving
Definition: vehicle.h:2007
bool handle_potential_theft(avatar &you, bool check_only=false, bool prompt=true)
Handle potential vehicle theft.
Definition: vehicle.cpp:4388
static const trait_id trait_WAYFARER("WAYFARER")

References _, add_msg(), vehicle::autopilot_on, vehicle::avail_part_with_feature(), choose_adjacent(), avatar::clear_memorized_tile(), Character::controlling_vehicle, vehicle::engine_on, fuel_type_animal, g, vehicle::get_points(), map::getabs(), vehicle::handle_potential_theft(), vehicle::has_engine_type(), vehicle::has_harnessed_animal(), Character::has_trait(), Character::in_vehicle, vehicle::interact_vehicle_locked(), vehicle::is_autodriving, vehicle::is_following, vehicle::is_patrolling, m, m_info, vehicle::name, optional_vpart_position::part_with_feature(), vehicle::player_in_control(), map::points_in_radius(), Character::pos(), remoteveh(), vehicle::start_engines(), trait_WAYFARER, u, vehicle::use_controls(), map::veh_at(), and vehicle::vehicle().

Referenced by handle_action().

◆ create_or_get_main_ui_adaptor()

shared_ptr_fast< ui_adaptor > game::create_or_get_main_ui_adaptor ( )

In tiles mode w_terrain can have a different font (with a different tile dimension) or can be drawn by cata_tiles which uses tiles that again might have a different dimension then the normal font used everywhere else.

TERRAIN_WINDOW_WIDTH/TERRAIN_WINDOW_HEIGHT defines how many squares can be displayed in w_terrain (using it's specific tile dimension), not including partially drawn squares at the right/bottom. You should use it whenever you want to draw specific squares in that window or to determine whether a specific square is draw on screen (or outside the screen and needs scrolling).

TERRAIN_WINDOW_TERM_WIDTH/TERRAIN_WINDOW_TERM_HEIGHT defines the size of w_terrain in the standard font dimension (the font that everything else uses). You usually don't have to use it, expect for positioning of windows, because the window positions use the standard font dimension.

The code here calculates size available for w_terrain, caps it at max_view_size (the maximal view range than any character can have at any time). It is stored in TERRAIN_WINDOW_*.

Definition at line 2917 of file game.cpp.

2918{
2920 if( !ui ) {
2921 main_ui_adaptor = ui = make_shared_fast<ui_adaptor>();
2922 ui->on_redraw( []( const ui_adaptor & ) {
2923 g->draw();
2924 } );
2925 ui->on_screen_resize( [this]( ui_adaptor & ui ) {
2926 // remove some space for the sidebar, this is the maximal space
2927 // (using standard font) that the terrain window can have
2928 const int sidebar_left = panel_manager::get_manager().get_width_left();
2929 const int sidebar_right = panel_manager::get_manager().get_width_right();
2930
2932 TERRAIN_WINDOW_WIDTH = TERMX - ( sidebar_left + sidebar_right );
2935
2936 /**
2937 * In tiles mode w_terrain can have a different font (with a different
2938 * tile dimension) or can be drawn by cata_tiles which uses tiles that again
2939 * might have a different dimension then the normal font used everywhere else.
2940 *
2941 * TERRAIN_WINDOW_WIDTH/TERRAIN_WINDOW_HEIGHT defines how many squares can
2942 * be displayed in w_terrain (using it's specific tile dimension), not
2943 * including partially drawn squares at the right/bottom. You should
2944 * use it whenever you want to draw specific squares in that window or to
2945 * determine whether a specific square is draw on screen (or outside the screen
2946 * and needs scrolling).
2947 *
2948 * TERRAIN_WINDOW_TERM_WIDTH/TERRAIN_WINDOW_TERM_HEIGHT defines the size of
2949 * w_terrain in the standard font dimension (the font that everything else uses).
2950 * You usually don't have to use it, expect for positioning of windows,
2951 * because the window positions use the standard font dimension.
2952 *
2953 * The code here calculates size available for w_terrain, caps it at
2954 * max_view_size (the maximal view range than any character can have at
2955 * any time).
2956 * It is stored in TERRAIN_WINDOW_*.
2957 */
2959
2960 // Position of the player in the terrain window, it is always in the center
2963
2965 point( sidebar_left, 0 ) );
2966
2967 // minimap is always MINIMAP_WIDTH x MINIMAP_HEIGHT in size
2969
2970 // need to init in order to avoid crash. gets updated by the panel code.
2972
2973 ui.position_from_window( catacurses::stdscr );
2974 } );
2975 ui->mark_resize();
2976 }
2977 return ui;
2978}
catacurses::window w_pixel_minimap
Definition: game.h:990
catacurses::window w_minimap_ptr
Definition: game.h:1027
weak_ptr_fast< ui_adaptor > main_ui_adaptor
Definition: game.h:1073
catacurses::window w_minimap
Definition: game.h:989
catacurses::window w_terrain_ptr
Definition: game.h:1026
static panel_manager & get_manager()
Definition: panels.h:72
int get_width_right()
Definition: panels.cpp:2186
int get_width_left()
Definition: panels.cpp:2194
Adaptor between UI code and the UI management system.
Definition: ui_manager.h:65
static constexpr int MINIMAP_WIDTH
static constexpr int MINIMAP_HEIGHT
void to_map_font_dimension(int &, int &)
Definition: game_ui.cpp:20
std::shared_ptr< T > shared_ptr_fast
Definition: memory_fast.h:16
window stdscr
Definition: overmap_ui.h:17
int TERRAIN_WINDOW_TERM_WIDTH
Definition: output.cpp:53
int TERRAIN_WINDOW_TERM_HEIGHT
Definition: output.cpp:54
int POSX
Definition: output.cpp:49
int TERRAIN_WINDOW_WIDTH
Definition: output.cpp:51
int POSY
Definition: output.cpp:50
int TERRAIN_WINDOW_HEIGHT
Definition: output.cpp:52

References g, panel_manager::get_manager(), panel_manager::get_width_left(), panel_manager::get_width_right(), main_ui_adaptor, MINIMAP_HEIGHT, MINIMAP_WIDTH, catacurses::newwin(), point_zero, POSX, POSY, catacurses::stdscr, TERMX, TERMY, TERRAIN_WINDOW_HEIGHT, TERRAIN_WINDOW_TERM_HEIGHT, TERRAIN_WINDOW_TERM_WIDTH, TERRAIN_WINDOW_WIDTH, to_map_font_dimension(), w_minimap, w_minimap_ptr, w_pixel_minimap, w_terrain, and w_terrain_ptr.

◆ create_starting_npcs()

void game::create_starting_npcs ( )
private

Definition at line 891 of file game.cpp.

892{
893 if( !get_option<bool>( "STATIC_NPC" ) ||
894 get_option<std::string>( "STARTING_NPC" ) == "never" ) {
895 return; //Do not generate a starting npc.
896 }
897
898 //We don't want more than one starting npc per starting location
899 const int radius = 1;
900 if( !overmap_buffer.get_npcs_near_player( radius ).empty() ) {
901 return; //There is already an NPC in this starting location
902 }
903
904 shared_ptr_fast<npc> tmp = make_shared_fast<npc>();
905 tmp->randomize( one_in( 2 ) ? NC_DOCTOR : NC_NONE );
906 tmp->spawn_at_precise( { get_levx(), get_levy() }, u.pos() - point_south_east );
908 tmp->form_opinion( u );
909 tmp->set_attitude( NPCATT_NULL );
910 //This sets the NPC mission. This NPC remains in the starting location.
911 tmp->mission = NPC_MISSION_SHELTER;
912 tmp->chatbin.first_topic = "TALK_SHELTER";
913 tmp->toggle_trait( trait_id( "NPC_STARTING_NPC" ) );
914 tmp->set_fac( faction_id( "no_faction" ) );
915 //One random starting NPC mission
916 tmp->add_new_mission( mission::reserve_random( ORIGIN_OPENER_NPC, tmp->global_omt_location(),
917 tmp->getID() ) );
918}
int get_levy() const
Definition: game.cpp:11891
int get_levx() const
The top left corner of the reality bubble (in submaps coordinates).
Definition: game.cpp:11886
static mission * reserve_random(mission_origin origin, const tripoint_abs_omt &p, const character_id &npc_id)
Definition: mission.cpp:200
std::vector< shared_ptr_fast< npc > > get_npcs_near_player(int radius)
Same as get_npcs_near(int,int,int,int) but uses player position as center.
void insert_npc(const shared_ptr_fast< npc > &who)
Adds the npc to an overmap ( based on the npcs current location ) and stores it there.
string_id< faction > faction_id
Definition: clzones.h:30
@ ORIGIN_OPENER_NPC
Definition: mission.h:45
@ NPCATT_NULL
Definition: npc.h:81
@ NPC_MISSION_SHELTER
Definition: npc.h:144
npc_class_id NC_NONE("NC_NONE")
npc_class_id NC_DOCTOR("NC_DOCTOR")
static constexpr point point_south_east
Definition: point.h:265
bool one_in(int chance)
Definition: rng.cpp:65

References get_levx(), get_levy(), overmapbuffer::get_npcs_near_player(), overmapbuffer::insert_npc(), NC_DOCTOR, NC_NONE, NPC_MISSION_SHELTER, NPCATT_NULL, one_in(), ORIGIN_OPENER_NPC, overmap_buffer, point_south_east, Character::pos(), mission::reserve_random(), trait_id, and u.

Referenced by start_game().

◆ critter_at() [1/2]

template<typename T >
T * game::critter_at ( const tripoint p,
bool  allow_hallucination = false 
)

Returns the Creature at the given location.

Optionally casted to the given type of creature: npc, player, monster - if there is a creature, but it's not of the requested type, returns nullptr.

Parameters
allow_hallucinationWhether to return monsters that are actually hallucinations.

Definition at line 4535 of file game.cpp.

4536{
4537 if( const shared_ptr_fast<monster> mon_ptr = critter_tracker->find( p ) ) {
4538 if( !allow_hallucination && mon_ptr->is_hallucination() ) {
4539 return nullptr;
4540 }
4541 // if we wanted to check for an NPC / player / avatar,
4542 // there is sometimes a monster AND an NPC/player there at the same time.
4543 // because the NPC/player etc may be riding that monster.
4544 // so only return the monster if we were actually looking for a monster.
4545 // otherwise, keep looking for the rider.
4546 // critter_at<creature> or critter_at() with no template will still default to returning monster first,
4547 // which is ok for the occasions where that happens.
4548 if( !mon_ptr->has_effect( effect_ridden ) || ( std::is_same<T, monster>::value ||
4549 std::is_same<T, Creature>::value || std::is_same<T, const monster>::value ||
4550 std::is_same<T, const Creature>::value ) ) {
4551 return dynamic_cast<T *>( mon_ptr.get() );
4552 }
4553 }
4554 if( !std::is_same<T, npc>::value && !std::is_same<T, const npc>::value ) {
4555 if( p == u.pos() ) {
4556 return dynamic_cast<T *>( &u );
4557 }
4558 }
4559 for( auto &cur_npc : active_npc ) {
4560 if( cur_npc->pos() == p && !cur_npc->is_dead() ) {
4561 return dynamic_cast<T *>( cur_npc.get() );
4562 }
4563 }
4564 return nullptr;
4565}
static const efftype_id effect_ridden("ridden")

References active_npc, critter_tracker, effect_ridden, Character::pos(), and u.

Referenced by draw_look_around_cursor(), examine(), find_or_make_stairs(), fling_creature(), forced_door_closing(), get_player_input(), is_empty(), knockback(), phasing_move(), print_all_tile_info(), spawn_hallucination(), swap_critters(), and update_stair_monsters().

◆ critter_at() [2/2]

template<typename T >
const T * game::critter_at ( const tripoint p,
bool  allow_hallucination = false 
) const

Definition at line 4568 of file game.cpp.

4569{
4570 return const_cast<game *>( this )->critter_at<T>( p, allow_hallucination );
4571}
Definition: game.h:144

◆ critter_by_id()

template<typename T >
template Creature * game::critter_by_id< Creature > ( const character_id id)
Returns
The living creature with the given id. Returns null if no living creature with such an id exists. Never returns a dead creature. Currently only the player character and npcs have ids.

Definition at line 4614 of file game.cpp.

4615{
4616 if( id == u.getID() ) {
4617 // player is always alive, therefore no is-dead check
4618 return dynamic_cast<T *>( &u );
4619 }
4620 return find_npc( id );
4621}
character_id getID() const
Definition: character.cpp:491
npc * find_npc(character_id id)
Find the npc with the given ID.
Definition: game.cpp:1879

References find_npc(), Character::getID(), and u.

◆ death_screen()

void game::death_screen ( )
private

Definition at line 2428 of file game.cpp.

2429{
2430 gamemode->game_over();
2435 follower_ids.clear();
2437}
diary * get_avatar_diary()
Definition: avatar.cpp:369
void death_entry()
Definition: diary.cpp:672
stats_tracker & stats()
Definition: game.cpp:2722
void disp_NPC_epilogues()
Definition: game.cpp:2804
void display_faction_epilogues()
Definition: game.cpp:2821
void display_messages()
Definition: messages.cpp:827
void show_scores_ui(const achievements_tracker &achievements, stats_tracker &stats, const kill_tracker &kills)
Definition: scores_ui.cpp:69

References achievements_tracker_ptr, diary::death_entry(), disp_NPC_epilogues(), display_faction_epilogues(), Messages::display_messages(), follower_ids, gamemode, avatar::get_avatar_diary(), get_kill_tracker(), show_scores_ui(), stats(), and u.

Referenced by cleanup_at_end().

◆ despawn_monster()

void game::despawn_monster ( monster critter)

Despawn a specific monster, it's stored on the overmap.

Also removes it from the creature tracker. Keep in mind that any monster index may point to a different monster after calling this (or to no monster at all).

Definition at line 11010 of file game.cpp.

11011{
11012 if( !critter.is_hallucination() ) {
11013 // hallucinations aren't stored, they come and go as they like,
11015 }
11016
11017 critter.on_unload();
11018 remove_zombie( critter );
11019 // simulate it being dead so further processing of it (e.g. in monmove) will yield
11020 critter.set_hp( 0 );
11021}
void remove_zombie(const monster &critter)
Definition: game.cpp:4725
bool is_hallucination() const override
Definition: monster.cpp:2709
void on_unload()
Do some cleanup and caching as monster is being unloaded from map.
Definition: monster.cpp:3045
void set_hp(int hp)
Directly set the current hp of the monster (not capped at the maximal hp).
Definition: monster.cpp:1680
void despawn_monster(const monster &critter)
Despawn the monster back onto the overmap.

References overmapbuffer::despawn_monster(), monster::is_hallucination(), monster::on_unload(), overmap_buffer, remove_zombie(), and monster::set_hp().

Referenced by cleanup_at_end(), monmove(), place_player_overmap(), and shift_monsters().

◆ disable_robot()

bool game::disable_robot ( const tripoint p)

If there is a robot (that can be disabled), query the player and try to disable it.

Returns
true if the robot has been disabled or a similar action has been done. false if the player did not choose any action and the function has effectively done nothing.

Definition at line 8633 of file game.cpp.

8634{
8635 monster *const mon_ptr = critter_at<monster>( p );
8636 if( !mon_ptr ) {
8637 return false;
8638 }
8639 monster &critter = *mon_ptr;
8640 if( critter.friendly == 0 || critter.has_effect( effect_pet ) ||
8641 critter.has_flag( MF_RIDEABLE_MECH ) ||
8642 ( critter.has_flag( MF_PAY_BOT ) && critter.has_effect( effect_paid ) ) ) {
8643 // Can only disable / reprogram friendly monsters
8644 return false;
8645 }
8646 const auto mid = critter.type->id;
8647 const auto mon_item_id = critter.type->revert_to_itype;
8648 if( !mon_item_id.is_empty() &&
8649 query_yn( _( "Deactivate the %s?" ), critter.name() ) ) {
8650
8651 u.moves -= 100;
8652 m.add_item_or_charges( p, critter.to_item() );
8653 if( !critter.has_flag( MF_INTERIOR_AMMO ) ) {
8654 for( auto &ammodef : critter.ammo ) {
8655 if( ammodef.second > 0 ) {
8656 m.spawn_item( p.xy(), ammodef.first, 1, ammodef.second, calendar::turn );
8657 }
8658 }
8659 }
8660 remove_zombie( critter );
8661 return true;
8662 }
8663 // Manhacks are special, they have their own menu here.
8664 if( mid == mon_manhack ) {
8665 int choice = UILIST_CANCEL;
8666 if( critter.has_effect( effect_docile ) ) {
8667 choice = uilist( _( "Reprogram the manhack?" ), { _( "Engage targets." ) } );
8668 } else {
8669 choice = uilist( _( "Reprogram the manhack?" ), { _( "Follow me." ) } );
8670 }
8671 switch( choice ) {
8672 case 0:
8673 if( critter.has_effect( effect_docile ) ) {
8674 critter.remove_effect( effect_docile );
8675 if( one_in( 3 ) ) {
8676 add_msg( _( "The %s hovers momentarily as it surveys the area." ),
8677 critter.name() );
8678 }
8679 } else {
8680 critter.add_effect( effect_docile, 1_turns, num_bp );
8681 if( one_in( 3 ) ) {
8682 add_msg( _( "The %s lets out a whirring noise and starts to follow you." ),
8683 critter.name() );
8684 }
8685 }
8686 u.moves -= 100;
8687 return true;
8688 default:
8689 break;
8690 }
8691 }
8692 return false;
8693}
@ num_bp
Definition: bodypart.h:52
bool remove_effect(const efftype_id &eff_id, body_part bp=num_bp)
Removes a listed effect.
Definition: creature.cpp:1144
void spawn_item(const tripoint &p, const itype_id &type_id, unsigned quantity=1, int charges=0, const time_point &birthday=calendar::start_of_cataclysm, int damlevel=0)
Definition: map.cpp:4292
bool has_flag(m_flag f) const override
Definition: monster.cpp:894
item to_item() const
Convert this monster into an item (see mtype::revert_to_itype).
Definition: monster.cpp:2849
void add_effect(const efftype_id &eff_id, const time_duration &dur, const bodypart_str_id &bp, int intensity=0, bool force=false, bool deferred=false) override
Performs any monster-specific modifications to the arguments before passing to Creature::add_effect()...
Definition: monster.cpp:1856
int friendly
Definition: monster.h:471
std::string name(unsigned int quantity=1) const
Definition: monster.cpp:489
std::map< itype_id, int > ammo
Definition: monster.h:512
static const efftype_id effect_pet("pet")
static const efftype_id effect_docile("docile")
static const efftype_id effect_paid("paid")
static const mtype_id mon_manhack("mon_manhack")
@ MF_INTERIOR_AMMO
Definition: mtype.h:146
@ MF_RIDEABLE_MECH
Definition: mtype.h:115
@ MF_PAY_BOT
Definition: mtype.h:121
itype_id revert_to_itype
If this is not empty, the monster can be converted into an item of this type (if it's friendly).
Definition: mtype.h:364
constexpr point xy() const
Definition: point.h:206
const int UILIST_CANCEL
Definition: ui.h:28

References _, monster::add_effect(), map::add_item_or_charges(), add_msg(), monster::ammo, effect_docile, effect_paid, effect_pet, monster::friendly, Creature::has_effect(), monster::has_flag(), mtype::id, m, MF_INTERIOR_AMMO, MF_PAY_BOT, MF_RIDEABLE_MECH, mon_manhack, Creature::moves, monster::name(), num_bp, one_in(), query_yn(), Creature::remove_effect(), remove_zombie(), mtype::revert_to_itype, map::spawn_item(), monster::to_item(), calendar::turn, monster::type, u, UILIST_CANCEL, and tripoint::xy().

Referenced by examine().

◆ disp_NPC_epilogues()

void game::disp_NPC_epilogues ( )
private

Definition at line 2804 of file game.cpp.

2805{
2806 // TODO: This search needs to be expanded to all NPCs
2807 for( auto elem : follower_ids ) {
2809 if( !guy ) {
2810 continue;
2811 }
2812 const auto new_win = []() {
2814 point( std::max( 0, ( TERMX - FULL_SCREEN_WIDTH ) / 2 ),
2815 std::max( 0, ( TERMY - FULL_SCREEN_HEIGHT ) / 2 ) ) );
2816 };
2817 scrollable_text( new_win, guy->disp_name(), guy->get_epilogue() );
2818 }
2819}
shared_ptr_fast< npc > find_npc(character_id id)
Find the npc with the given ID.
void scrollable_text(const std::function< catacurses::window()> &init_window, const std::string &title, const std::string &text)
Definition: output.cpp:352

References overmapbuffer::find_npc(), follower_ids, FULL_SCREEN_HEIGHT, FULL_SCREEN_WIDTH, catacurses::newwin(), overmap_buffer, scrollable_text(), TERMX, and TERMY.

Referenced by death_screen().

◆ disp_NPCs()

void game::disp_NPCs ( )

Definition at line 2855 of file game.cpp.

2856{
2857 const tripoint_abs_omt ppos = u.global_omt_location();
2858 const tripoint &lpos = u.pos();
2859 std::vector<shared_ptr_fast<npc>> npcs = overmap_buffer.get_npcs_near_player( 100 );
2860 std::sort( npcs.begin(), npcs.end(), npc_dist_to_player() );
2861
2863 ui_adaptor ui;
2864 ui.on_screen_resize( [&]( ui_adaptor & ui ) {
2867 TERMY > FULL_SCREEN_HEIGHT ? ( TERMY - FULL_SCREEN_HEIGHT ) / 2 : 0 ) );
2868 ui.position_from_window( w );
2869 } );
2870 ui.mark_resize();
2871 ui.on_redraw( [&]( const ui_adaptor & ) {
2872 werase( w );
2873 mvwprintz( w, point_zero, c_white, _( "Your overmap position: %s" ), ppos.to_string() );
2874 // NOLINTNEXTLINE(cata-use-named-point-constants)
2875 mvwprintz( w, point( 0, 1 ), c_white, _( "Your local position: %s" ), lpos.to_string() );
2876 size_t i;
2877 for( i = 0; i < 20 && i < npcs.size(); i++ ) {
2878 const tripoint_abs_omt apos = npcs[i]->global_omt_location();
2879 mvwprintz( w, point( 0, i + 3 ), c_white, "%s: %s", npcs[i]->name,
2880 apos.to_string() );
2881 }
2882 for( const monster &m : all_monsters() ) {
2883 mvwprintz( w, point( 0, i + 3 ), c_white, "%s: %d, %d, %d", m.name(),
2884 m.posx(), m.posy(), m.posz() );
2885 ++i;
2886 }
2887 wnoutrefresh( w );
2888 } );
2889
2890 input_context ctxt( "DISP_NPCS" );
2891 ctxt.register_action( "CONFIRM" );
2892 ctxt.register_action( "QUIT" );
2893 ctxt.register_action( "HELP_KEYBINDINGS" );
2894 bool stop = false;
2895 while( !stop ) {
2897 const std::string action = ctxt.handle_input();
2898 if( action == "CONFIRM" || action == "QUIT" ) {
2899 stop = true;
2900 }
2901 }
2902}
tripoint_abs_omt global_omt_location() const
Returns the location of the player in global overmap terrain coordinates.
Definition: character.cpp:6257
std::string to_string() const
Definition: coordinates.h:140
Represents a context in which a set of actions can be performed.
Definition: input.h:382
std::string name(const tripoint &p)
Definition: map.cpp:1389
void wnoutrefresh(const window &win)
Definition: ncurses_def.cpp:43
void werase(const window &win)
Definition: ncurses_def.cpp:53
std::string to_string() const
Definition: point.cpp:34

References _, action, all_monsters(), c_white, FULL_SCREEN_HEIGHT, FULL_SCREEN_WIDTH, overmapbuffer::get_npcs_near_player(), Character::global_omt_location(), input_context::handle_input(), m, mvwprintz(), map::name(), om_direction::name(), catacurses::newwin(), overmap_buffer, point_zero, Character::pos(), ui_manager::redraw(), input_context::register_action(), TERMX, TERMY, coords::coord_point< Point, Origin, Scale >::to_string(), tripoint::to_string(), u, catacurses::werase(), and catacurses::wnoutrefresh().

◆ display_faction_epilogues()

void game::display_faction_epilogues ( )
private

Definition at line 2821 of file game.cpp.

2822{
2823 for( const auto &elem : faction_manager_ptr->all() ) {
2824 if( elem.second.known_by_u ) {
2825 const std::vector<std::string> epilogue = elem.second.epilogue();
2826 if( !epilogue.empty() ) {
2827 const auto new_win = []() {
2829 point( std::max( 0, ( TERMX - FULL_SCREEN_WIDTH ) / 2 ),
2830 std::max( 0, ( TERMY - FULL_SCREEN_HEIGHT ) / 2 ) ) );
2831 };
2832 scrollable_text( new_win, elem.second.name,
2833 std::accumulate( epilogue.begin() + 1, epilogue.end(), epilogue.front(),
2834 []( const std::string & lhs, const std::string & rhs ) -> std::string {
2835 return lhs + "\n" + rhs;
2836 } ) );
2837 }
2838 }
2839 }
2840}
pimpl< faction_manager > faction_manager_ptr
Definition: game.h:973

References faction_manager_ptr, FULL_SCREEN_HEIGHT, FULL_SCREEN_WIDTH, catacurses::newwin(), scrollable_text(), TERMX, and TERMY.

Referenced by death_screen().

◆ display_lighting()

void game::display_lighting ( )
private

Definition at line 11236 of file game.cpp.

11237{
11238 if( use_tiles ) {
11240 if( !g->display_overlay_state( ACTION_DISPLAY_LIGHTING ) ) {
11241 return;
11242 }
11243 uilist lighting_menu;
11244 std::vector<std::string> lighting_menu_strings{
11245 "Global lighting conditions"
11246 };
11247
11248 int count = 0;
11249 for( const auto &menu_str : lighting_menu_strings ) {
11250 lighting_menu.addentry( count++, true, MENU_AUTOASSIGN, "%s", menu_str );
11251 }
11252
11253 lighting_menu.w_y_setup = 0;
11254 lighting_menu.query();
11255 if( ( lighting_menu.ret >= 0 ) &&
11256 ( static_cast<size_t>( lighting_menu.ret ) < lighting_menu_strings.size() ) ) {
11257 g->displaying_lighting_condition = lighting_menu.ret;
11258 }
11259 }
11260}
@ ACTION_DISPLAY_LIGHTING
Toggle lighting conditions map.
Definition: action.h:317
bool use_tiles
Use tiles for display.
void display_toggle_overlay(action_id)
Definition: game.cpp:11132
pos_scalar w_y_setup
Definition: ui.h:338
constexpr size_t count()
Definition: fmtlib_core.h:1073
const int MENU_AUTOASSIGN
Definition: ui.h:31

References ACTION_DISPLAY_LIGHTING, uilist::addentry(), detail::count(), display_toggle_overlay(), g, MENU_AUTOASSIGN, uilist::query(), uilist::ret, use_tiles, and uilist::w_y_setup.

Referenced by handle_action(), and look_around().

◆ display_overlay_state()

bool game::display_overlay_state ( action_id  action)

Definition at line 11127 of file game.cpp.

11128{
11130}
std::optional< action_id > displaying_overlays
Definition: game.h:918

References action, and displaying_overlays.

Referenced by display_toggle_overlay(), and display_visibility().

◆ display_radiation()

void game::display_radiation ( )
private

Definition at line 11262 of file game.cpp.

11263{
11264 if( use_tiles ) {
11266 }
11267}
@ ACTION_DISPLAY_RADIATION
Toggle radiation map.
Definition: action.h:319

References ACTION_DISPLAY_RADIATION, display_toggle_overlay(), and use_tiles.

Referenced by handle_action(), and look_around().

◆ display_scent()

void game::display_scent ( )
private

Definition at line 11141 of file game.cpp.

11142{
11143 if( use_tiles ) {
11145 } else {
11146 int div;
11147 bool got_value = query_int( div, _( "Set the Scent Map sensitivity to (0 to cancel)?" ) );
11148 if( !got_value || div < 1 ) {
11149 add_msg( _( "Never mind." ) );
11150 return;
11151 }
11152 shared_ptr_fast<game::draw_callback_t> scent_cb = make_shared_fast<game::draw_callback_t>( [&]() {
11153 scent.draw( w_terrain, div * 2, u.pos() + u.view_offset );
11154 } );
11155 g->add_draw_callback( scent_cb );
11156
11159 }
11160}
@ ACTION_DISPLAY_SCENT
Toggle scent map.
Definition: action.h:279
void wait_for_any_key()
Wait until the user presses a key.
Definition: input.cpp:1303
tripoint view_offset
Definition: player.h:233
void draw(const catacurses::window &win, int div, const tripoint &center) const
Definition: scent_map.cpp:70
input_manager inp_mngr
Definition: input.cpp:109
bool query_int(int &result, int default_val, const std::string &text)
Definition: output.cpp:718

References _, ACTION_DISPLAY_SCENT, add_msg(), display_toggle_overlay(), scent_map::draw(), g, inp_mngr, Character::pos(), query_int(), ui_manager::redraw(), scent, u, use_tiles, player::view_offset, w_terrain, and input_manager::wait_for_any_key().

Referenced by handle_action(), and look_around().

◆ display_temperature()

void game::display_temperature ( )
private

Definition at line 11162 of file game.cpp.

11163{
11164 if( use_tiles ) {
11166 }
11167}
@ ACTION_DISPLAY_TEMPERATURE
Toggle temperature map.
Definition: action.h:311

References ACTION_DISPLAY_TEMPERATURE, display_toggle_overlay(), and use_tiles.

Referenced by handle_action(), and look_around().

◆ display_toggle_overlay()

void game::display_toggle_overlay ( action_id  action)

Definition at line 11132 of file game.cpp.

11133{
11134 if( display_overlay_state( action ) ) {
11135 displaying_overlays.reset();
11136 } else {
11138 }
11139}
bool display_overlay_state(action_id)
Definition: game.cpp:11127

References action, display_overlay_state(), and displaying_overlays.

Referenced by display_lighting(), display_radiation(), display_scent(), display_temperature(), display_transparency(), display_vehicle_ai(), and display_visibility().

◆ display_transparency()

void game::display_transparency ( )
private

Definition at line 11269 of file game.cpp.

11270{
11271 if( use_tiles ) {
11273 }
11274}
@ ACTION_DISPLAY_TRANSPARENCY
Toggle transparency map.
Definition: action.h:321

References ACTION_DISPLAY_TRANSPARENCY, display_toggle_overlay(), and use_tiles.

Referenced by handle_action(), and look_around().

◆ display_vehicle_ai()

void game::display_vehicle_ai ( )
private

Definition at line 11169 of file game.cpp.

11170{
11171 if( use_tiles ) {
11173 }
11174}
@ ACTION_DISPLAY_VEHICLE_AI
Toggle vehicle autopilot data.
Definition: action.h:313

References ACTION_DISPLAY_VEHICLE_AI, display_toggle_overlay(), and use_tiles.

Referenced by handle_action().

◆ display_visibility()

void game::display_visibility ( )
private

Definition at line 11176 of file game.cpp.

11177{
11178 if( use_tiles ) {
11181 std::vector< tripoint > locations;
11182 uilist creature_menu;
11183 int num_creatures = 0;
11184 creature_menu.addentry( num_creatures++, true, MENU_AUTOASSIGN, "%s", _( "You" ) );
11185 locations.emplace_back( g->u.pos() ); // add player first.
11186 for( const Creature &critter : g->all_creatures() ) {
11187 if( critter.is_player() ) {
11188 continue;
11189 }
11190 creature_menu.addentry( num_creatures++, true, MENU_AUTOASSIGN, critter.disp_name() );
11191 locations.emplace_back( critter.pos() );
11192 }
11193
11194 pointmenu_cb callback( locations );
11195 creature_menu.callback = &callback;
11196 creature_menu.w_y_setup = 0;
11197 creature_menu.query();
11198 if( creature_menu.ret >= 0 && static_cast<size_t>( creature_menu.ret ) < locations.size() ) {
11199 Creature *creature = critter_at<Creature>( locations[creature_menu.ret] );
11201 }
11202 } else {
11204 }
11205 }
11206}
@ ACTION_DISPLAY_VISIBILITY
Toggle visibility map.
Definition: action.h:315
size_t num_creatures() const
Returns the approximate number of creatures in the reality bubble.
Definition: game.cpp:4715
Creature * displaying_visibility_creature
Creature for which to display the visibility map.
Definition: game.h:1009
Callback for uilist that pairs menu entries with points When an entry is selected,...
Definition: ui.h:423
uilist_callback * callback
Definition: ui.h:335
generic_factory< overmap_location > locations("overmap location")

References _, ACTION_DISPLAY_VISIBILITY, uilist::addentry(), uilist::callback, creature, display_overlay_state(), display_toggle_overlay(), displaying_visibility_creature, g, anonymous_namespace{overmap_location.cpp}::locations, MENU_AUTOASSIGN, num_creatures(), uilist::query(), uilist::ret, use_tiles, and uilist::w_y_setup.

Referenced by handle_action().

◆ do_turn()

bool game::do_turn ( )

MAIN GAME LOOP.

Returns true if game is over (death, saved, quit, etc.).

Definition at line 1353 of file game.cpp.

1354{
1355 if( is_game_over() ) {
1356 return cleanup_at_end();
1357 }
1358 // Actual stuff
1359 if( new_game ) {
1360 new_game = false;
1361 } else {
1362 gamemode->per_turn();
1363 calendar::turn += 1_turns;
1364 }
1365
1366 // starting a new turn, clear out temperature cache
1368 weather.clear_temp_cache();
1369
1370 if( npcs_dirty ) {
1371 load_npcs();
1372 }
1373
1376 // If controlling a vehicle that is owned by someone else
1378 vehicle *veh = veh_pointer_or_null( m.veh_at( u.pos() ) );
1379 if( veh && !veh->handle_potential_theft( u, true ) ) {
1380 veh->handle_potential_theft( u, false, false );
1381 }
1382 }
1383 // If riding a horse - chance to spook
1384 if( u.is_mounted() ) {
1386 }
1387 if( calendar::once_every( 1_days ) ) {
1389 }
1390
1391 // Move hordes every 2.5 min
1394 // Hordes that reached the reality bubble need to spawn,
1395 // make them spawn in invisible areas only.
1396 m.spawn_monsters( false );
1397 }
1398
1400
1401 u.update_body();
1402
1403 // Auto-save if autosave is enabled
1404 if( get_option<bool>( "AUTOSAVE" ) &&
1405 calendar::once_every( 1_turns * get_option<int>( "AUTOSAVE_TURNS" ) ) &&
1406 !u.is_dead_state() ) {
1407 autosave();
1408 }
1409
1410 weather.update_weather();
1412
1416 // Process NPC sound events before they move or they hear themselves talking
1417 for( npc &guy : all_npcs() ) {
1418 if( rl_dist( guy.pos(), u.pos() ) < MAX_VIEW_DISTANCE ) {
1420 }
1421 }
1422
1423 // Process sound events into sound markers for display to the player.
1425
1426 if( u.is_deaf() ) {
1428 }
1429
1430 if( !u.has_effect( effect_sleep ) || uquit == QUIT_WATCH ) {
1431 if( u.moves > 0 || uquit == QUIT_WATCH ) {
1432 while( u.moves > 0 || uquit == QUIT_WATCH ) {
1433 cleanup_dead();
1435 // Process any new sounds the player caused during their turn.
1436 for( npc &guy : all_npcs() ) {
1437 if( rl_dist( guy.pos(), u.pos() ) < MAX_VIEW_DISTANCE ) {
1439 }
1440 }
1443 wait_popup.reset();
1445 }
1446
1447 if( queue_screenshot ) {
1451 queue_screenshot = false;
1452 }
1453
1454 if( handle_action() ) {
1456 u.action_taken();
1457 }
1458
1459 if( is_game_over() ) {
1460 return cleanup_at_end();
1461 }
1462
1463 if( uquit == QUIT_WATCH ) {
1464 break;
1465 }
1466 if( u.activity ) {
1468 }
1469 }
1470 // Reset displayed sound markers now that the turn is over.
1471 // We only want this to happen if the player had a chance to examine the sounds.
1473 }
1474 }
1475
1476 if( driving_view_offset.x != 0 || driving_view_offset.y != 0 ) {
1477 // Still have a view offset, but might not be driving anymore,
1478 // or the option has been deactivated,
1479 // might also happen when someone dives from a moving car.
1480 // or when using the handbrake.
1481 vehicle *veh = veh_pointer_or_null( m.veh_at( u.pos() ) );
1482 calc_driving_offset( veh );
1483 }
1484
1485 // No-scent debug mutation has to be processed here or else it takes time to start working
1486 if( !u.has_active_bionic( bionic_id( "bio_scent_mask" ) ) &&
1487 !u.has_trait( trait_id( "DEBUG_NOSCENT" ) ) ) {
1490 }
1491 scent.update( u.pos(), m );
1492
1493 // We need floor cache before checking falling 'n stuff
1495
1498 m.vehmove();
1499 m.process_fields();
1500 m.process_items();
1503
1504 // Apply sounds from previous turn to monster and NPC AI.
1506 // Update vision caches for monsters. If this turns out to be expensive,
1507 // consider a stripped down cache just for monsters.
1508 m.build_map_cache( get_levz(), true );
1509 monmove();
1510 if( calendar::once_every( 5_minutes ) ) {
1512 }
1513 if( calendar::once_every( 10_seconds ) ) {
1514 for( const tripoint &elem : m.get_furn_field_locations() ) {
1515 const auto &furn = m.furn( elem ).obj();
1516 for( const emit_id &e : furn.emissions ) {
1517 m.emit_field( elem, e );
1518 }
1519 }
1520 }
1523 u.process_turn();
1524
1526 cleanup_dead();
1527
1528 if( u.moves < 0 && get_option<bool>( "FORCE_REDRAW" ) ) {
1531 }
1532
1533 if( get_levz() >= 0 && !u.is_underwater() ) {
1534 handle_weather_effects( weather.weather_id );
1535 }
1536
1537 const bool player_is_sleeping = u.has_effect( effect_sleep );
1538 bool wait_redraw = false;
1539 std::string wait_message;
1540 time_duration wait_refresh_rate;
1541 if( player_is_sleeping ) {
1542 wait_redraw = true;
1543 wait_message = _( "Wait till you wake up…" );
1544 wait_refresh_rate = 30_minutes;
1545 if( calendar::once_every( 1_hours ) ) {
1547 }
1548 } else if( u.has_destination() ) {
1549 wait_redraw = true;
1550 wait_message = _( "Travelling…" );
1551 wait_refresh_rate = 15_turns;
1552 } else if( const std::optional<std::string> progress = u.activity.get_progress_message( u ) ) {
1553 wait_redraw = true;
1554 wait_message = *progress;
1555 if( u.activity.id() == ACT_AUTODRIVE ) {
1556 wait_refresh_rate = 1_turns;
1557 } else {
1558 wait_refresh_rate = 5_minutes;
1559 }
1560 }
1561 if( wait_redraw ) {
1563 calendar::once_every( std::min( 1_minutes, wait_refresh_rate ) ) ) {
1564 if( first_redraw_since_waiting_started || calendar::once_every( wait_refresh_rate ) ) {
1566 }
1567
1568 // Avoid redrawing the main UI every time due to invalidation
1570 wait_popup = std::make_unique<static_popup>();
1571 wait_popup->on_top( true ).wait_message( "%s", wait_message );
1575 }
1576 } else {
1577 // Nothing to wait for now
1578 wait_popup.reset();
1580 }
1581
1584 u.apply_wetness_morale( weather.temperature );
1585
1586 if( calendar::once_every( 1_minutes ) ) {
1587 u.update_morale();
1588 }
1589
1590 if( calendar::once_every( 9_turns ) ) {
1592 }
1593
1594 if( !u.is_deaf() ) {
1596 }
1601
1602 // reset player noise
1603 u.volume = 0;
1604
1605 return false;
1606}
void update_morale()
Ticks down morale counters and removes them.
Definition: character.cpp:8982
void action_taken()
Called after every action, invalidates player caches.
Definition: character.cpp:809
bool check_mount_is_spooked()
Definition: character.cpp:1037
void process_turn() override
Handles end-of-turn processing.
void update_bodytemp(const map &m, const weather_manager &weather)
Maintains body temperature.
Definition: character.cpp:5205
bool is_mounted() const
Definition: character.cpp:1078
bool has_destination() const
scenttype_id get_type_of_scent() const
Definition: character.cpp:8741
bool is_dead_state() const override
Returns true if the character should be dead.
Definition: character.cpp:496
bool check_and_recover_morale()
Checks permanent morale for consistency and recovers it when an inconsistency is found.
Definition: character.cpp:9109
bool is_deaf() const
Definition: character.cpp:4500
void update_body()
Updates all "biology" by one turn.
Definition: character.cpp:4679
bool has_active_bionic(const bionic_id &b) const
Returns true if the player has the entered bionic id and it is powered on.
Definition: character.cpp:1819
void apply_wetness_morale(int temperature)
Recalculates morale penalty/bonus from wetness based on mutations, equipment and temperature.
Definition: suffer.cpp:1865
virtual bool is_underwater() const
Definition: creature.cpp:171
int get_levz() const
Definition: game.cpp:11896
void overmap_npc_move()
Definition: game.cpp:4195
class game::debug_hour_timer debug_hour_timer
npc_range all_npcs()
Same as all_creatures but iterators only over npcs.
Definition: game.cpp:12006
void monmove()
Definition: game.cpp:4069
void autopilot_vehicles()
process vehicles that are following the player
Definition: game.cpp:1671
void add_artifact_dreams()
Definition: game.cpp:11838
int moves_since_last_save
Definition: game.h:1039
bool take_screenshot() const
Saves a screenshot of the current viewport, as a PNG file.
Definition: game.cpp:7151
void calc_driving_offset(vehicle *veh=nullptr)
Definition: game.cpp:1251
bool cleanup_at_end()
Definition: game.cpp:947
std::unique_ptr< static_popup > wait_popup
Definition: game.h:1075
bool queue_screenshot
Definition: game.h:1018
friend weather_manager & get_weather()
Definition: weather.cpp:64
void autosave()
Definition: game.cpp:11327
void process_activity()
Definition: game.cpp:1660
void update_stair_monsters()
Definition: game.cpp:10801
void process_voluntary_act_interrupt()
Definition: game.cpp:1620
void load_npcs()
Makes any nearby NPCs on the overmap active.
Definition: game.cpp:816
bool npcs_dirty
Has a NPC been spawned since last load?
Definition: game.h:1046
void cleanup_dead()
Definition: game.cpp:4034
bool is_game_over()
Definition: game.cpp:2375
void perhaps_add_random_npc()
Definition: game.cpp:11059
void mon_info_update()
Definition: game.cpp:3833
bool handle_action()
const T & obj() const
Definition: ammo_effect.cpp:26
void build_floor_caches()
Definition: map.cpp:8167
void process_falling()
Invoked drop_everything on cached dirty tiles.
Definition: map.cpp:2355
void emit_field(const tripoint &pos, const emit_id &src, float mul=1.0f)
Runs one cycle of emission src which may result in propagation of fields.
Definition: map_field.cpp:1927
const std::vector< tripoint > & get_furn_field_locations() const
Definition: map.cpp:7859
void spawn_monsters(bool ignore_sight)
Spawn monsters from submap spawn points and from the overmap.
Definition: map.cpp:7818
void vehmove()
Definition: map.cpp:473
void creature_in_field(Creature &critter)
Apply field effects to the creature when it's on a square with fields.
Definition: map_field.cpp:1562
void process_fields()
Definition: map_field.cpp:141
furn_id furn(const tripoint &p) const
Definition: map.cpp:1412
void build_map_cache(int zlev, bool skip_lightmap=false)
Definition: map.cpp:8333
void process_items()
Definition: map.cpp:4678
static void process_all()
Handles mission deadline processing.
Definition: mission.cpp:98
void set_scent(const tripoint_abs_omt &loc, int strength)
Method to set a scent trace.
void process_mongroups()
Process nearby monstergroups (dying mostly).
void move_hordes()
Let hordes move a step.
const activity_id & id() const
std::optional< std::string > get_progress_message(const avatar &u) const
Helper that returns an activity specific progress message.
int volume
Definition: player.h:236
int scent
Definition: player.h:245
void set(const tripoint &p, int value, const scenttype_id &type=scenttype_id())
Get the scent value at the given position.
Definition: scent_map.cpp:102
void update(const tripoint &center, map &m)
Definition: scent_map.cpp:150
static constexpr time_duration from_minutes(const T m)
Definition: calendar.h:212
void process()
Process all queued events, potentially altering the game state and modifying the event queue.
static const activity_id ACT_AUTODRIVE("ACT_AUTODRIVE")
static const efftype_id effect_sleep("sleep")
@ QUIT_WATCH
Definition: game.h:73
static constexpr int MAX_VIEW_DISTANCE
void handle_weather_effects(const weather_type_id &w)
Definition: weather.cpp:522
bool once_every(const time_duration &event_frequency)
Predicate to handle rate-limiting.
Definition: calendar.cpp:490
void update_body_wetness(Character &who, const w_point &weather)
Maintains body wetness and handles the rate at which the player dries.
explosion_queue & get_explosion_queue()
Definition: explosion.cpp:1920
void do_vehicle_engine_sfx()
Definition: sounds.cpp:1612
void do_hearing_loss(int turns=-1)
Definition: sounds.cpp:1607
void do_danger_music()
Definition: sounds.cpp:1611
void do_vehicle_exterior_engine_sfx()
Definition: sounds.cpp:1613
void do_fatigue()
Definition: sounds.cpp:1632
void remove_hearing_loss()
Definition: sounds.cpp:1608
void process_sound_markers(player *p)
Definition: sounds.cpp:386
void process_sounds()
Definition: sounds.cpp:304
void reset_markers()
Definition: sounds.cpp:572
vehicle * veh_pointer_or_null(const optional_vpart_position &p)

References _, ACT_AUTODRIVE, Character::action_taken(), Character::activity, add_artifact_dreams(), all_npcs(), Character::apply_wetness_morale(), autopilot_vehicles(), autosave(), map::build_floor_caches(), map::build_map_cache(), calc_driving_offset(), Character::check_and_recover_morale(), Character::check_mount_is_spooked(), cleanup_at_end(), cleanup_dead(), Character::controlling_vehicle, map::creature_in_field(), sfx::do_danger_music(), sfx::do_fatigue(), sfx::do_hearing_loss(), sfx::do_vehicle_engine_sfx(), sfx::do_vehicle_exterior_engine_sfx(), driving_view_offset, effect_sleep, map::emit_field(), explosion_handler::explosion_queue::execute(), first_redraw_since_waiting_started, time_duration::from_minutes(), map::furn(), gamemode, explosion_handler::get_explosion_queue(), map::get_furn_field_locations(), get_levz(), player_activity::get_progress_message(), Character::get_type_of_scent(), get_weather, Character::global_omt_location(), grid_tracker_ptr, handle_action(), vehicle::handle_potential_theft(), handle_weather_effects(), Character::has_active_bionic(), Character::has_destination(), Character::has_distant_destination(), Creature::has_effect(), Character::has_trait(), player_activity::id(), Character::in_vehicle, invalidate_main_ui_adaptor(), Character::is_dead_state(), Character::is_deaf(), is_game_over(), Character::is_mounted(), Creature::is_underwater(), load_npcs(), m, MAX_VIEW_DISTANCE, mon_info_update(), monmove(), overmapbuffer::move_hordes(), Creature::moves, moves_since_last_save, new_game, npcs_dirty, int_id< T >::obj(), calendar::once_every(), overmap_buffer, overmap_npc_move(), perhaps_add_random_npc(), Character::pos(), game::debug_hour_timer::print_time(), timed_event_manager::process(), process_activity(), mission::process_all(), map::process_falling(), map::process_fields(), map::process_items(), overmapbuffer::process_mongroups(), sounds::process_sound_markers(), sounds::process_sounds(), Character::process_turn(), process_voluntary_act_interrupt(), queue_screenshot, QUIT_WATCH, ui_manager::redraw(), refresh_display(), sfx::remove_hearing_loss(), reset_light_level(), sounds::reset_markers(), rl_dist(), scent, player::scent, scent_map::set(), overmapbuffer::set_scent(), map::spawn_monsters(), take_screenshot(), timed_events, calendar::turn, u, scent_map::update(), Character::update_body(), character_funcs::update_body_wetness(), Character::update_bodytemp(), Character::update_morale(), update_stair_monsters(), uquit, map::veh_at(), veh_pointer_or_null(), map::vehmove(), player::volume, wait_popup, point::x, and point::y.

◆ draw()

void game::draw ( )

Definition at line 3092 of file game.cpp.

3093{
3094 if( test_mode ) {
3095 return;
3096 }
3097
3098 //temporary fix for updating visibility for minimap
3099 ter_view_p.z = ( u.pos() + u.view_offset ).z;
3102
3103 werase( w_terrain );
3104 draw_ter();
3105 for( auto it = draw_callbacks.begin(); it != draw_callbacks.end(); ) {
3106 shared_ptr_fast<draw_callback_t> cb = it->lock();
3107 if( cb ) {
3108 ( *cb )();
3109 ++it;
3110 } else {
3111 it = draw_callbacks.erase( it );
3112 }
3113 }
3115
3116 draw_panels( true );
3117}
bool test_mode
Set to true when running in test mode (e.g.
tripoint ter_view_p
Definition: game.h:985
void draw_panels(bool force_draw=false)
Definition: game.cpp:3119
void draw_ter(bool draw_sounds=true)
Definition: game.cpp:3233
void update_visibility_cache(int zlev)
Definition: map.cpp:5707
int z
Definition: point.h:138

References map::build_map_cache(), draw_callbacks, draw_panels(), draw_ter(), m, Character::pos(), ter_view_p, test_mode, u, map::update_visibility_cache(), player::view_offset, w_terrain, catacurses::werase(), catacurses::wnoutrefresh(), and tripoint::z.

◆ draw_below_override()

void game::draw_below_override ( const tripoint p,
bool  draw 
)

Definition at line 1023 of file animation.cpp.

1024{
1025}

◆ draw_bullet()

void game::draw_bullet ( const tripoint t,
int  i,
const std::vector< tripoint > &  trajectory,
char  bullet 
)

Definition at line 578 of file animation.cpp.

580{
581 draw_bullet_curses( m, t, bullet, &trajectory[i] );
582}
void draw_bullet_curses(map &m, const tripoint &t, const char bullet, const tripoint *const p)
Definition: animation.cpp:460
std::vector< tripoint > trajectory
Definition: ranged.h:37

References anonymous_namespace{animation.cpp}::draw_bullet_curses(), and m.

◆ draw_critter()

void game::draw_critter ( const Creature critter,
const tripoint center 
)

Definition at line 3215 of file game.cpp.

3216{
3217 draw_critter_internal( w_terrain, critter, center, false, m, u );
3218}
static void draw_critter_internal(const catacurses::window &w, const Creature &critter, const tripoint &center, bool inverted, const map &m, const avatar &u)
Definition: game.cpp:3182

References center, draw_critter_internal(), m, u, and w_terrain.

Referenced by draw_ter().

◆ draw_critter_highlighted()

void game::draw_critter_highlighted ( const Creature critter,
const tripoint center 
)

Definition at line 3220 of file game.cpp.

3221{
3222 draw_critter_internal( w_terrain, critter, center, true, m, u );
3223}

References center, draw_critter_internal(), m, u, and w_terrain.

◆ draw_cursor()

void game::draw_cursor ( const tripoint p)

Definition at line 784 of file animation.cpp.

785{
786 const tripoint rp = relative_view_pos( *this, p );
787 mvwputch_inv( w_terrain, rp.xy(), c_light_green, 'X' );
788}
#define c_light_green
Definition: color.h:28
tripoint relative_view_pos(const game &g, const tripoint &p) noexcept
Definition: animation.cpp:128
void mvwputch_inv(const catacurses::window &w, point p, nc_color FG, int ch)
Definition: output.cpp:491

References c_light_green, mvwputch_inv(), anonymous_namespace{animation.cpp}::relative_view_pos(), w_terrain, and tripoint::xy().

Referenced by draw_look_around_cursor().

◆ draw_field_override()

void game::draw_field_override ( const tripoint p,
const field_type_id id 
)

Definition at line 979 of file animation.cpp.

980{
981}

◆ draw_furniture_override()

void game::draw_furniture_override ( const tripoint p,
const furn_id id 
)

Definition at line 940 of file animation.cpp.

941{
942}

◆ draw_graffiti_override()

void game::draw_graffiti_override ( const tripoint p,
bool  has 
)

Definition at line 953 of file animation.cpp.

954{
955}

◆ draw_highlight()

void game::draw_highlight ( const tripoint p)

Definition at line 797 of file animation.cpp.

798{
799 // Do nothing
800}

◆ draw_hit_mon()

void game::draw_hit_mon ( const tripoint p,
const monster m,
bool  dead = false 
)

Definition at line 641 of file animation.cpp.

642{
643 draw_hit_mon_curses( p, m, u, dead );
644}
void draw_hit_mon_curses(const tripoint &center, const monster &m, const player &u, const bool dead)
Definition: animation.cpp:612

References dead, anonymous_namespace{animation.cpp}::draw_hit_mon_curses(), m, and u.

◆ draw_hit_player()

void game::draw_hit_player ( const Character p,
int  dam 
)

Definition at line 686 of file animation.cpp.

687{
688 draw_hit_player_curses( *this, p, dam );
689}
void draw_hit_player_curses(const game &g, const Character &p, const int dam)
Definition: animation.cpp:649

References anonymous_namespace{animation.cpp}::draw_hit_player_curses().

◆ draw_item_override()

void game::draw_item_override ( const tripoint p,
const itype_id id,
const mtype_id mid,
bool  hilite 
)

Definition at line 993 of file animation.cpp.

995{
996}

◆ draw_line() [1/2]

void game::draw_line ( const tripoint p,
const std::vector< tripoint > &  points 
)

Definition at line 770 of file animation.cpp.

771{
772 draw_line_curses( *this, points );
773}
void draw_line_curses(game &g, const std::vector< tripoint > &points)
Definition: animation.cpp:750

References anonymous_namespace{animation.cpp}::draw_line_curses().

◆ draw_line() [2/2]

void game::draw_line ( const tripoint p,
const tripoint center_point,
const std::vector< tripoint > &  points,
bool  noreveal = false 
)

Definition at line 737 of file animation.cpp.

739{
740 if( !u.sees( p ) ) {
741 return;
742 }
743
744 draw_line_curses( *this, center, points, noreveal );
745}

References center, anonymous_namespace{animation.cpp}::draw_line_curses(), Character::sees(), and u.

Referenced by draw_ter().

◆ draw_look_around_cursor()

void game::draw_look_around_cursor ( const tripoint lp,
const visibility_variables cache 
)

Definition at line 5683 of file game.cpp.

5684{
5685 if( !liveview.is_enabled() ) {
5686#if defined( TILES )
5687 if( is_draw_tiles_mode() ) {
5688 draw_cursor( lp );
5689 return;
5690 }
5691#endif
5692 const tripoint view_center = u.pos() + u.view_offset;
5693 visibility_type visibility = VIS_HIDDEN;
5694 const bool inbounds = m.inbounds( lp );
5695 if( inbounds ) {
5696 visibility = m.get_visibility( m.apparent_light_at( lp, cache ), cache );
5697 }
5698 if( visibility == VIS_CLEAR ) {
5699 const Creature *const creature = critter_at( lp, true );
5700 if( creature != nullptr && u.sees( *creature ) ) {
5701 creature->draw( w_terrain, view_center, true );
5702 } else {
5703 m.drawsq( w_terrain, lp, drawsq_params().highlight( true ).center( view_center ) );
5704 }
5705 } else {
5706 std::string visibility_indicator;
5707 nc_color visibility_indicator_color = c_white;
5708 switch( visibility ) {
5709 case VIS_CLEAR:
5710 // Already handled by the outer if statement
5711 break;
5712 case VIS_BOOMER:
5713 case VIS_BOOMER_DARK:
5714 visibility_indicator = '#';
5715 visibility_indicator_color = c_pink;
5716 break;
5717 case VIS_DARK:
5718 visibility_indicator = '#';
5719 visibility_indicator_color = c_dark_gray;
5720 break;
5721 case VIS_LIT:
5722 visibility_indicator = '#';
5723 visibility_indicator_color = c_light_gray;
5724 break;
5725 case VIS_HIDDEN:
5726 visibility_indicator = 'x';
5727 visibility_indicator_color = c_white;
5728 break;
5729 }
5730
5731 const tripoint screen_pos = point( POSX, POSY ) + lp - view_center;
5732 mvwputch( w_terrain, screen_pos.xy(), visibility_indicator_color, visibility_indicator );
5733 }
5734 }
5735}
void draw_cursor(const tripoint &p)
Definition: animation.cpp:784
T * critter_at(const tripoint &p, bool allow_hallucination=false)
Returns the Creature at the given location.
Definition: game.cpp:4535
bool is_enabled()
Definition: live_view.cpp:75
virtual bool inbounds(const tripoint &p) const
Definition: map.cpp:7874
visibility_type get_visibility(lit_level ll, const visibility_variables &cache) const
Definition: map.cpp:5761
lit_level apparent_light_at(const tripoint &p, const visibility_variables &cache) const
Determine the visible light level for a tile, based on light_at for the tile, vision distance,...
Definition: lightmap.cpp:764
void drawsq(const catacurses::window &w, const tripoint &p, const drawsq_params &params) const
Draw the map tile at the given coordinate.
Definition: map.cpp:5939
#define c_dark_gray
Definition: color.h:20
#define c_pink
Definition: color.h:31
visibility_type
Definition: enums.h:57
@ VIS_CLEAR
Definition: enums.h:59
@ VIS_BOOMER
Definition: enums.h:61
@ VIS_DARK
Definition: enums.h:62
@ VIS_BOOMER_DARK
Definition: enums.h:63
@ VIS_HIDDEN
Definition: enums.h:58
@ VIS_LIT
Definition: enums.h:60
bool is_draw_tiles_mode()
Check whether we're in tile drawing mode.
Definition: output.cpp:2075
Draw parameters used by map::drawsq() and similar methods.
Definition: map.h:180

References map::apparent_light_at(), c_dark_gray, c_light_gray, c_pink, c_white, center, creature, critter_at(), draw_cursor(), map::drawsq(), map::get_visibility(), map::inbounds(), is_draw_tiles_mode(), live_view::is_enabled(), liveview, m, mvwputch(), Character::pos(), POSX, POSY, Character::sees(), u, player::view_offset, VIS_BOOMER, VIS_BOOMER_DARK, VIS_CLEAR, VIS_DARK, VIS_HIDDEN, VIS_LIT, w_terrain, and tripoint::xy().

Referenced by look_around().

◆ draw_minimap()

void game::draw_minimap ( )
private

Definition at line 3293 of file game.cpp.

3294{
3295
3296 // Draw the box
3297 werase( w_minimap );
3299
3300 const tripoint_abs_omt curs = u.global_omt_location();
3301 const point_abs_omt curs2( curs.xy() );
3303 bool drew_mission = targ == overmap::invalid_tripoint;
3304
3305 for( int i = -2; i <= 2; i++ ) {
3306 for( int j = -2; j <= 2; j++ ) {
3307 const point_abs_omt om( curs2 + point( i, j ) );
3308 nc_color ter_color;
3309 tripoint_abs_omt omp( om, get_levz() );
3310 std::string ter_sym;
3311 const bool seen = overmap_buffer.seen( omp );
3312 const bool vehicle_here = overmap_buffer.has_vehicle( omp );
3313 if( overmap_buffer.has_note( omp ) ) {
3314
3315 const std::string &note_text = overmap_buffer.note( omp );
3316
3317 ter_color = c_yellow;
3318 ter_sym = "N";
3319
3320 int symbolIndex = note_text.find( ':' );
3321 int colorIndex = note_text.find( ';' );
3322
3323 bool symbolFirst = symbolIndex < colorIndex;
3324
3325 if( colorIndex > -1 && symbolIndex > -1 ) {
3326 if( symbolFirst ) {
3327 if( colorIndex > 4 ) {
3328 colorIndex = -1;
3329 }
3330 if( symbolIndex > 1 ) {
3331 symbolIndex = -1;
3332 colorIndex = -1;
3333 }
3334 } else {
3335 if( symbolIndex > 4 ) {
3336 symbolIndex = -1;
3337 }
3338 if( colorIndex > 2 ) {
3339 colorIndex = -1;
3340 }
3341 }
3342 } else if( colorIndex > 2 ) {
3343 colorIndex = -1;
3344 } else if( symbolIndex > 1 ) {
3345 symbolIndex = -1;
3346 }
3347
3348 if( symbolIndex > -1 ) {
3349 int symbolStart = 0;
3350 if( colorIndex > -1 && !symbolFirst ) {
3351 symbolStart = colorIndex + 1;
3352 }
3353 ter_sym = note_text.substr( symbolStart, symbolIndex - symbolStart ).c_str()[0];
3354 }
3355
3356 if( colorIndex > -1 ) {
3357
3358 int colorStart = 0;
3359
3360 if( symbolIndex > -1 && symbolFirst ) {
3361 colorStart = symbolIndex + 1;
3362 }
3363
3364 std::string sym = note_text.substr( colorStart, colorIndex - colorStart );
3365
3366 if( sym.length() == 2 ) {
3367 if( sym == "br" ) {
3368 ter_color = c_brown;
3369 } else if( sym == "lg" ) {
3370 ter_color = c_light_gray;
3371 } else if( sym == "dg" ) {
3372 ter_color = c_dark_gray;
3373 }
3374 } else {
3375 char colorID = sym.c_str()[0];
3376 if( colorID == 'r' ) {
3377 ter_color = c_light_red;
3378 } else if( colorID == 'R' ) {
3379 ter_color = c_red;
3380 } else if( colorID == 'g' ) {
3381 ter_color = c_light_green;
3382 } else if( colorID == 'G' ) {
3383 ter_color = c_green;
3384 } else if( colorID == 'b' ) {
3385 ter_color = c_light_blue;
3386 } else if( colorID == 'B' ) {
3387 ter_color = c_blue;
3388 } else if( colorID == 'W' ) {
3389 ter_color = c_white;
3390 } else if( colorID == 'C' ) {
3391 ter_color = c_cyan;
3392 } else if( colorID == 'c' ) {
3393 ter_color = c_light_cyan;
3394 } else if( colorID == 'P' ) {
3395 ter_color = c_pink;
3396 } else if( colorID == 'm' ) {
3397 ter_color = c_magenta;
3398 }
3399 }
3400 }
3401 } else if( !seen ) {
3402 ter_sym = " ";
3403 ter_color = c_black;
3404 } else if( vehicle_here ) {
3405 ter_color = c_cyan;
3406 ter_sym = "c";
3407 } else {
3408 const oter_id &cur_ter = overmap_buffer.ter( omp );
3409 ter_sym = cur_ter->get_symbol();
3410 if( overmap_buffer.is_explored( omp ) ) {
3411 ter_color = c_dark_gray;
3412 } else {
3413 ter_color = cur_ter->get_color();
3414 }
3415 }
3416 if( !drew_mission && targ.xy() == omp.xy() ) {
3417 // If there is a mission target, and it's not on the same
3418 // overmap terrain as the player character, mark it.
3419 // TODO: Inform player if the mission is above or below
3420 drew_mission = true;
3421 if( i != 0 || j != 0 ) {
3422 ter_color = red_background( ter_color );
3423 }
3424 }
3425 if( i == 0 && j == 0 ) {
3426 mvwputch_hi( w_minimap, point( 3, 3 ), ter_color, ter_sym );
3427 } else {
3428 mvwputch( w_minimap, point( 3 + i, 3 + j ), ter_color, ter_sym );
3429 }
3430 }
3431 }
3432
3433 // Print arrow to mission if we have one!
3434 if( !drew_mission ) {
3435 double slope = curs2.x() != targ.x() ?
3436 static_cast<double>( targ.y() - curs2.y() ) / ( targ.x() - curs2.x() ) : 4;
3437
3438 if( curs2.x() == targ.x() || std::fabs( slope ) > 3.5 ) { // Vertical slope
3439 if( targ.y() > curs2.y() ) {
3440 mvwputch( w_minimap, point( 3, 6 ), c_red, "*" );
3441 } else {
3442 mvwputch( w_minimap, point( 3, 0 ), c_red, "*" );
3443 }
3444 } else {
3445 int arrowx = -1;
3446 int arrowy = -1;
3447 if( std::fabs( slope ) >= 1. ) { // y diff is bigger!
3448 arrowy = targ.y() > curs2.y() ? 6 : 0;
3449 arrowx =
3450 static_cast<int>( 3 + 3 * ( targ.y() > curs2.y() ? slope : ( 0 - slope ) ) );
3451 if( arrowx < 0 ) {
3452 arrowx = 0;
3453 }
3454 if( arrowx > 6 ) {
3455 arrowx = 6;
3456 }
3457 } else {
3458 arrowx = targ.x() > curs2.x() ? 6 : 0;
3459 arrowy = static_cast<int>( 3 + 3 * ( targ.x() > curs2.x() ? slope : -slope ) );
3460 if( arrowy < 0 ) {
3461 arrowy = 0;
3462 }
3463 if( arrowy > 6 ) {
3464 arrowy = 6;
3465 }
3466 }
3467 char glyph = '*';
3468 if( targ.z() > u.posz() ) {
3469 glyph = '^';
3470 } else if( targ.z() < u.posz() ) {
3471 glyph = 'v';
3472 }
3473
3474 mvwputch( w_minimap, point( arrowx, arrowy ), c_red, glyph );
3475 }
3476 }
3477
3478 const int sight_points = g->u.overmap_sight_range( g->light_level( g->u.posz() ) );
3479 for( int i = -3; i <= 3; i++ ) {
3480 for( int j = -3; j <= 3; j++ ) {
3481 if( i > -3 && i < 3 && j > -3 && j < 3 ) {
3482 continue; // only do hordes on the border, skip inner map
3483 }
3484 const tripoint_abs_omt omp( curs2 + point( i, j ), get_levz() );
3486 if( overmap_buffer.seen( omp )
3487 && g->u.overmap_los( omp, sight_points ) ) {
3488 mvwputch( w_minimap, point( i + 3, j + 3 ), c_green,
3489 overmap_buffer.get_horde_size( omp ) > HORDE_VISIBILITY_SIZE * 2 ? 'Z' : 'z' );
3490 }
3491 }
3492 }
3493 }
3494
3496}
tripoint_abs_omt get_active_mission_target() const
Returns the target of the active mission or overmap::invalid_tripoint if there is no active mission.
Definition: avatar.cpp:206
constexpr auto & x()
Definition: coordinates.h:118
constexpr auto & z()
Definition: coordinates.h:133
constexpr auto & y()
Definition: coordinates.h:124
constexpr auto xy() const
Definition: coordinates.h:130
static constexpr tripoint_abs_omt invalid_tripoint
Dummy value, used to indicate that a point returned by a function is invalid.
Definition: overmap.h:260
bool seen(const tripoint_abs_omt &p)
const std::string & note(const tripoint_abs_omt &p)
int get_horde_size(const tripoint_abs_omt &p)
bool is_explored(const tripoint_abs_omt &p)
const oter_id & ter(const tripoint_abs_omt &p)
Returns the overmap terrain at the given OMT coordinates.
bool has_note(const tripoint_abs_omt &p)
Uses global overmap terrain coordinates.
bool has_vehicle(const tripoint_abs_omt &p)
nc_color red_background(const nc_color &c)
Definition: color.cpp:515
#define c_blue
Definition: color.h:23
#define c_black
Definition: color.h:17
#define c_light_blue
Definition: color.h:29
#define c_yellow
Definition: color.h:32
#define c_light_cyan
Definition: color.h:30
#define c_cyan
Definition: color.h:24
#define c_light_red
Definition: color.h:27
static constexpr int HORDE_VISIBILITY_SIZE
constexpr scale om
Definition: coordinates.h:34
void mvwputch_hi(const catacurses::window &w, point p, nc_color FG, int ch)
Definition: output.cpp:508
std::string get_symbol(const bool from_land_use_code=false) const
Definition: omdata.h:209
nc_color get_color(const bool from_land_use_code=false) const
Definition: omdata.h:217

References c_black, c_blue, c_brown, c_cyan, c_dark_gray, c_green, c_light_blue, c_light_cyan, c_light_gray, c_light_green, c_light_red, c_magenta, c_pink, c_red, c_white, c_yellow, draw_border(), units::fabs(), g, avatar::get_active_mission_target(), oter_t::get_color(), overmapbuffer::get_horde_size(), get_levz(), oter_t::get_symbol(), Character::global_omt_location(), overmapbuffer::has_note(), overmapbuffer::has_vehicle(), HORDE_VISIBILITY_SIZE, overmap::invalid_tripoint, overmapbuffer::is_explored(), mvwputch(), mvwputch_hi(), overmapbuffer::note(), coords::om, overmap_buffer, Character::posz(), red_background(), overmapbuffer::seen(), overmapbuffer::ter(), u, w_minimap, catacurses::werase(), catacurses::wnoutrefresh(), coords::coord_point< Point, Origin, Scale >::x(), coords::coord_point< Point, Origin, Scale >::xy(), coords::coord_point< Point, Origin, Scale >::y(), and coords::coord_point< Point, Origin, Scale >::z().

◆ draw_monster_override()

void game::draw_monster_override ( const tripoint p,
const mtype_id id,
int  count,
bool  more,
Creature::Attitude  att 
)

Definition at line 1037 of file animation.cpp.

1039{
1040}

◆ draw_panels()

void game::draw_panels ( bool  force_draw = false)

Definition at line 3119 of file game.cpp.

3120{
3121 static int previous_turn = -1;
3122 const int current_turn = to_turns<int>( calendar::turn - calendar::turn_zero );
3123 const bool draw_this_turn = current_turn > previous_turn || force_draw;
3124 auto &mgr = panel_manager::get_manager();
3125 int y = 0;
3126 const bool sidebar_right = get_option<std::string>( "SIDEBAR_POSITION" ) == "right";
3127 int spacer = get_option<bool>( "SIDEBAR_SPACERS" ) ? 1 : 0;
3128 int log_height = 0;
3129 for( const window_panel &panel : mgr.get_current_layout() ) {
3130 if( panel.get_height() != -2 && panel.toggle && panel.render() ) {
3131 log_height += panel.get_height() + spacer;
3132 }
3133 }
3134 log_height = std::max( TERMY - log_height, 3 );
3135 for( const window_panel &panel : mgr.get_current_layout() ) {
3136 if( panel.render() ) {
3137 // height clamped to window height.
3138 int h = std::min( panel.get_height(), TERMY - y );
3139 if( h == -2 ) {
3140 h = log_height;
3141 }
3142 h += spacer;
3143 if( panel.toggle && panel.render() && h > 0 ) {
3144 if( panel.always_draw || draw_this_turn ) {
3145 panel.draw( u, catacurses::newwin( h, panel.get_width(),
3146 point( sidebar_right ? TERMX - panel.get_width() : 0, y ) ) );
3147 }
3148 if( show_panel_adm ) {
3149 const std::string panel_name = _( panel.get_name() );
3150 const int panel_name_width = utf8_width( panel_name );
3151 auto label = catacurses::newwin( 1, panel_name_width, point( sidebar_right ?
3152 TERMX - panel.get_width() - panel_name_width - 1 : panel.get_width() + 1, y ) );
3153 werase( label );
3154 mvwprintz( label, point_zero, c_light_red, panel_name );
3156 label = catacurses::newwin( h, 1,
3157 point( sidebar_right ? TERMX - panel.get_width() - 1 : panel.get_width(), y ) );
3158 werase( label );
3159 if( h == 1 ) {
3161 } else {
3163 for( int i = 1; i < h - 1; i++ ) {
3165 }
3166 mvwputch( label, point( 0, h - 1 ), c_light_red, sidebar_right ? LINE_XXOO : LINE_XOOX );
3167 }
3169 }
3170 y += h;
3171 }
3172 }
3173 }
3174 previous_turn = current_turn;
3175}
bool show_panel_adm
Definition: game.h:1013
const time_point turn_zero
Represents time point 0.
Definition: calendar.cpp:26
#define LINE_XOXO
Definition: output.h:39
#define LINE_OXOX
Definition: output.h:40
#define LINE_OXXX
Definition: output.h:48
#define LINE_XOOX
Definition: output.h:44
#define LINE_XXOO
Definition: output.h:41
Struct used for storing labels (easier to json opposed to a std::map<point, std::string>)
Definition: vehicle.h:579

References _, c_light_red, panel_manager::get_manager(), LINE_OXOX, LINE_OXXX, LINE_XOOX, LINE_XOXO, LINE_XXOO, mvwprintz(), mvwputch(), catacurses::newwin(), point_zero, show_panel_adm, TERMX, TERMY, calendar::turn, calendar::turn_zero, u, utf8_width(), catacurses::werase(), and catacurses::wnoutrefresh().

Referenced by draw().

◆ draw_pixel_minimap()

void game::draw_pixel_minimap ( const catacurses::window w)

Definition at line 3177 of file game.cpp.

3178{
3179 w_pixel_minimap = w;
3180}

References w_pixel_minimap.

◆ draw_radiation_override()

void game::draw_radiation_override ( const tripoint p,
int  rad 
)

Definition at line 914 of file animation.cpp.

915{
916}

◆ draw_sct()

void game::draw_sct ( )

Definition at line 865 of file animation.cpp.

866{
867 draw_sct_curses( *this );
868}
void draw_sct_curses(const game &g)
Definition: animation.cpp:832

References anonymous_namespace{animation.cpp}::draw_sct_curses().

Referenced by get_player_input().

◆ draw_ter() [1/2]

void game::draw_ter ( bool  draw_sounds = true)

Definition at line 3233 of file game.cpp.

3234{
3236 draw_sounds );
3237}
bool is_looking
Definition: game.h:224

References draw_ter(), is_looking, Character::pos(), u, and player::view_offset.

Referenced by draw(), and draw_ter().

◆ draw_ter() [2/2]

void game::draw_ter ( const tripoint center,
bool  looking = false,
bool  draw_sounds = true 
)

Definition at line 3239 of file game.cpp.

3240{
3242
3243 m.draw( w_terrain, center );
3244
3245 if( draw_sounds ) {
3247 }
3248
3249 for( Creature &critter : all_creatures() ) {
3250 draw_critter( critter, center );
3251 }
3252
3253 if( !destination_preview.empty() && u.view_offset.z == 0 ) {
3254 // Draw auto-move preview trail
3255 const tripoint &final_destination = destination_preview.back();
3256 tripoint line_center = u.pos() + u.view_offset;
3257 draw_line( final_destination, line_center, destination_preview, true );
3258 mvwputch( w_terrain, final_destination.xy() - u.view_offset.xy() + point( POSX - u.posx(),
3259 POSY - u.posy() ), c_white, 'X' );
3260 }
3261
3262 if( u.controlling_vehicle && !looking ) {
3263 draw_veh_dir_indicator( false );
3264 draw_veh_dir_indicator( true );
3265 }
3266 // Place the cursor over the player as is expected by screen readers.
3267 wmove( w_terrain, -center.xy() + g->u.pos().xy() + point( POSX, POSY ) );
3268}
int posx() const override
Definition: character.h:797
int posy() const override
Definition: character.h:800
void draw_critter(const Creature &critter, const tripoint &center)
Definition: game.cpp:3215
Creature_range all_creatures()
Returns an anonymous range that contains all creatures.
Definition: game.cpp:11996
std::vector< tripoint > destination_preview
Definition: game.h:1065
void draw_veh_dir_indicator(bool next)
Definition: game.cpp:3285
void draw_line(const tripoint &p, const tripoint &center_point, const std::vector< tripoint > &points, bool noreveal=false)
Definition: animation.cpp:737
void draw(const catacurses::window &w, const tripoint &center)
Draw a visible part of the map into w.
Definition: map.cpp:5811
static void draw_footsteps(const catacurses::window &window, const tripoint &offset)
Definition: game.cpp:2905
void wmove(const window &win, point p)
Definition: ncurses_def.cpp:98

References all_creatures(), c_white, center, Character::controlling_vehicle, destination_preview, map::draw(), draw_critter(), draw_footsteps(), draw_line(), draw_veh_dir_indicator(), g, m, mvwputch(), Character::pos(), Character::posx(), POSX, Character::posy(), POSY, ter_view_p, u, player::view_offset, w_terrain, catacurses::wmove(), tripoint::xy(), and tripoint::z.

◆ draw_terrain_override()

void game::draw_terrain_override ( const tripoint p,
const ter_id id 
)

Definition at line 927 of file animation.cpp.

928{
929}

◆ draw_trail_to_square()

void game::draw_trail_to_square ( const tripoint t,
bool  bDrawX 
)

Definition at line 6999 of file game.cpp.

7000{
7001 ::draw_trail( u.pos(), u.pos() + t, bDrawX );
7002}
static void draw_trail(const tripoint &start, const tripoint &end, bool bDrawX)
Definition: game.cpp:6969

References draw_trail(), Character::pos(), and u.

◆ draw_trap_override()

void game::draw_trap_override ( const tripoint p,
const trap_id id 
)

Definition at line 966 of file animation.cpp.

967{
968}

◆ draw_veh_dir_indicator()

void game::draw_veh_dir_indicator ( bool  next)

Definition at line 3285 of file game.cpp.

3286{
3287 if( const std::optional<tripoint> indicator_offset = get_veh_dir_indicator_location( next ) ) {
3288 auto col = next ? c_white : c_dark_gray;
3289 mvwputch( w_terrain, indicator_offset->xy() - u.view_offset.xy() + point( POSX, POSY ), col, 'X' );
3290 }
3291}
std::optional< tripoint > get_veh_dir_indicator_location(bool next) const
Returns the location where the indicator should go relative to the reality bubble,...
Definition: game.cpp:3270

References c_dark_gray, c_white, get_veh_dir_indicator_location(), mvwputch(), POSX, POSY, u, player::view_offset, w_terrain, and tripoint::xy().

Referenced by draw_ter().

◆ draw_vpart_override()

void game::draw_vpart_override ( const tripoint p,
const vpart_id id,
int  part_mod,
units::angle  veh_dir,
bool  hilite,
point  mount 
)

Definition at line 1009 of file animation.cpp.

1011{
1012}

◆ draw_weather()

void game::draw_weather ( const weather_printable wPrint)

Definition at line 824 of file animation.cpp.

825{
827}
void draw_weather_curses(const catacurses::window &win, const weather_printable &w)
Definition: animation.cpp:805

References anonymous_namespace{animation.cpp}::draw_weather_curses(), and w_terrain.

Referenced by get_player_input().

◆ draw_zones()

void game::draw_zones ( const tripoint start,
const tripoint end,
const tripoint offset 
)

Definition at line 900 of file animation.cpp.

901{
902 draw_zones_curses( w_terrain, start, end, offset );
903}
void draw_zones_curses(const catacurses::window &w, const tripoint &start, const tripoint &end, const tripoint &offset)
Definition: animation.cpp:873

References anonymous_namespace{animation.cpp}::draw_zones_curses(), and w_terrain.

◆ drop()

void game::drop ( )
private

Definition at line 8047 of file game.cpp.

8048{
8050}
void drop(item_location loc, const tripoint &where)
Drops an item to the specified location.
Definition: character.cpp:2446
drop_locations multidrop(player &p)
Select items to drop.

References Character::drop(), game_menus::inv::multidrop(), Character::pos(), and u.

Referenced by handle_action().

◆ drop_in_direction()

void game::drop_in_direction ( )
private

Definition at line 8052 of file game.cpp.

8053{
8054 if( const std::optional<tripoint> pnt = choose_adjacent( _( "Drop where?" ) ) ) {
8055 u.drop( game_menus::inv::multidrop( u ), *pnt );
8056 }
8057}

References _, choose_adjacent(), Character::drop(), game_menus::inv::multidrop(), and u.

Referenced by handle_action().

◆ dump_stats()

bool game::dump_stats ( const std::string &  what,
dump_mode  mode,
const std::vector< std::string > &  opts 
)

write statistics to stdout and

Returns
true if successful

Definition at line 39 of file dump.cpp.

41{
42 try {
44 } catch( const std::exception &err ) {
45 std::cerr << "Error loading data from json: " << err.what() << std::endl;
46 return false;
47 }
48
49 std::vector<std::string> header;
50 std::vector<std::vector<std::string>> rows;
51
52 int scol = 0; // sorting column
53
54 std::map<std::string, standard_npc> test_npcs;
55 test_npcs[ "S1" ] = standard_npc( "S1", { 0, 0, 2 }, { "gloves_survivor", "mask_lsurvivor" },
56 4, 8, 10, 8, 10 /* DEX 10, PER 10 */ );
57 test_npcs[ "S2" ] = standard_npc( "S2", { 0, 0, 3 }, { "gloves_fingerless", "sunglasses" },
58 4, 8, 8, 8, 10 /* PER 10 */ );
59 test_npcs[ "S3" ] = standard_npc( "S3", { 0, 0, 4 }, { "gloves_plate", "helmet_plate" },
60 4, 10, 8, 8, 8 /* STAT 10 */ );
61 test_npcs[ "S4" ] = standard_npc( "S4", { 0, 0, 5 }, {}, 0, 8, 10, 8, 10 /* DEX 10, PER 10 */ );
62 test_npcs[ "S5" ] = standard_npc( "S5", { 0, 0, 6 }, {}, 4, 8, 10, 8, 10 /* DEX 10, PER 10 */ );
63 test_npcs[ "S6" ] = standard_npc( "S6", { 0, 0, 7 }, { "gloves_hsurvivor", "mask_hsurvivor" },
64 4, 8, 10, 8, 10 /* DEX 10, PER 10 */ );
65
66 std::map<std::string, item> test_items;
67 test_items[ "G1" ] = item( "glock_19" ).ammo_set( itype_id( "9mm" ) );
68 test_items[ "G2" ] = item( "hk_mp5" ).ammo_set( itype_id( "9mm" ) );
69 test_items[ "G3" ] = item( "ar15" ).ammo_set( itype_id( "223" ) );
70 test_items[ "G4" ] = item( "remington_700" ).ammo_set( itype_id( "270" ) );
71 test_items[ "G4" ].put_in( item( "rifle_scope" ) );
72
73 if( what == "AMMO" ) {
74 header = {
75 "Name", "Ammo", "Volume", "Weight", "Stack",
76 "Range", "Dispersion", "Recoil", "Damage", "Pierce", "Damage multiplier"
77 };
78 auto dump = [&rows]( const item & obj ) {
79 std::vector<std::string> r;
80 r.push_back( obj.tname( 1, false ) );
81 r.push_back( obj.ammo_type().str() );
82 r.push_back( std::to_string( obj.volume() / units::legacy_volume_factor ) );
83 r.push_back( std::to_string( to_gram( obj.weight() ) ) );
84 r.push_back( std::to_string( obj.type->stack_size ) );
85 r.push_back( std::to_string( obj.type->ammo->range ) );
86 r.push_back( std::to_string( obj.type->ammo->dispersion ) );
87 r.push_back( std::to_string( obj.type->ammo->recoil ) );
88 damage_instance damage = obj.type->ammo->damage;
89 r.push_back( std::to_string( damage.total_damage() ) );
90 r.push_back( std::to_string( damage.empty() ? 0 : ( *damage.begin() ).res_pen ) );
91 rows.push_back( r );
92 };
93 for( const itype *e : item_controller->all() ) {
94 if( e->ammo ) {
95 dump( item( e, calendar::turn, item::solitary_tag {} ) );
96 }
97 }
98
99 } else if( what == "ARMOR" ) {
100 header = {
101 "Name", "Encumber (fit)", "Warmth", "Weight", "Storage", "Coverage", "Bash", "Cut", "Bullet", "Acid", "Fire"
102 };
103 auto dump = [&rows]( const item & obj ) {
104 std::vector<std::string> r;
105 r.push_back( obj.tname( 1, false ) );
106 r.push_back( std::to_string( obj.get_encumber( g->u ) ) );
107 r.push_back( std::to_string( obj.get_warmth() ) );
108 r.push_back( std::to_string( to_gram( obj.weight() ) ) );
109 r.push_back( std::to_string( obj.get_storage() / units::legacy_volume_factor ) );
110 r.push_back( std::to_string( obj.get_coverage() ) );
111 r.push_back( std::to_string( obj.bash_resist() ) );
112 r.push_back( std::to_string( obj.cut_resist() ) );
113 r.push_back( std::to_string( obj.bullet_resist() ) );
114 r.push_back( std::to_string( obj.acid_resist() ) );
115 r.push_back( std::to_string( obj.fire_resist() ) );
116 rows.push_back( r );
117 };
118
119 body_part bp = opts.empty() ? num_bp : get_body_part_token( opts.front() );
120
121 for( const itype *e : item_controller->all() ) {
122 if( e->armor ) {
123 item obj( e );
124 if( bp == num_bp || obj.covers( bp ) ) {
125 if( obj.has_flag( flag_VARSIZE ) ) {
126 obj.set_flag( "FIT" );
127 }
128 dump( obj );
129 }
130 }
131 }
132
133 } else if( what == "EDIBLE" ) {
134 header = {
135 "Name", "Volume", "Weight", "Stack", "Calories", "Quench", "Healthy"
136 };
137 for( const auto &v : vitamin::all() ) {
138 header.push_back( v.second.name() );
139 }
140 auto dump = [&rows]( const item & obj ) {
141 std::vector<std::string> r;
142 r.push_back( obj.tname( 1, false ) );
143 r.push_back( std::to_string( obj.volume() / units::legacy_volume_factor ) );
144 r.push_back( std::to_string( to_gram( obj.weight() ) ) );
145 r.push_back( std::to_string( obj.type->stack_size ) );
146 r.push_back( std::to_string( obj.get_comestible()->default_nutrition.kcal ) );
147 r.push_back( std::to_string( obj.get_comestible()->quench ) );
148 r.push_back( std::to_string( obj.get_comestible()->healthy ) );
149 auto vits = obj.get_comestible()->default_nutrition.vitamins;
150 for( const auto &v : vitamin::all() ) {
151 r.push_back( std::to_string( vits[ v.first ] ) );
152 }
153 rows.push_back( r );
154 };
155
156 for( const itype *e : item_controller->all() ) {
158
159 if( food.is_food() && g->u.can_eat( food ).success() ) {
160 dump( food );
161 }
162 }
163
164 } else if( what == "GUN" ) {
165 header = {
166 "Name", "Ammo", "Volume", "Weight", "Capacity",
167 "Range", "Dispersion", "Effective recoil", "Damage", "Pierce",
168 "Aim time", "Effective range", "Snapshot range", "Max range"
169 };
170
171 std::set<std::string> locations;
172 for( const itype *e : item_controller->all() ) {
173 if( e->gun ) {
174 std::transform( e->gun->valid_mod_locations.begin(),
175 e->gun->valid_mod_locations.end(),
176 std::inserter( locations, locations.begin() ),
177 []( const std::pair<gunmod_location, int> &q ) {
178 return q.first.name();
179 } );
180 }
181 }
182 for( const auto &e : locations ) {
183 header.push_back( e );
184 }
185
186 auto dump = [&rows, &locations]( const standard_npc & who, const item & obj ) {
187 std::vector<std::string> r;
188 r.push_back( obj.tname( 1, false ) );
189 r.push_back( !obj.ammo_types().empty() ? enumerate_as_string( obj.ammo_types().begin(),
190 obj.ammo_types().end(), []( const ammotype & at ) {
191 return at.str();
193 r.push_back( std::to_string( obj.volume() / units::legacy_volume_factor ) );
194 r.push_back( std::to_string( to_gram( obj.weight() ) ) );
195 r.push_back( std::to_string( obj.ammo_capacity() ) );
196 r.push_back( std::to_string( obj.gun_range() ) );
197 r.push_back( std::to_string( obj.gun_dispersion() ) );
198 r.push_back( std::to_string( obj.gun_recoil() ) );
199 damage_instance damage = obj.gun_damage();
200 r.push_back( std::to_string( damage.total_damage() ) );
201 r.push_back( std::to_string( damage.empty() ? 0 : ( *damage.begin() ).res_pen ) );
202
203 r.push_back( std::to_string( ranged::gun_engagement_moves( who, obj ) ) );
204
205 for( const auto &e : locations ) {
206 const auto &vml = obj.type->gun->valid_mod_locations;
207 const auto iter = vml.find( e );
208 r.push_back( std::to_string( iter != vml.end() ? iter->second : 0 ) );
209 }
210 rows.push_back( r );
211 };
212 for( const itype *e : item_controller->all() ) {
213 if( e->gun ) {
214 item gun( e );
215 if( !gun.magazine_integral() ) {
216 gun.put_in( item( gun.magazine_default() ) );
217 }
218 gun.ammo_set( gun.ammo_default( false ), gun.ammo_capacity() );
219
220 dump( test_npcs[ "S1" ], gun );
221
222 if( gun.type->gun->barrel_length > 0_ml ) {
223 gun.put_in( item( "barrel_small" ) );
224 dump( test_npcs[ "S1" ], gun );
225 }
226 }
227 }
228
229 } else if( what == "RECIPE" ) {
230
231 // optionally filter recipes to include only those using specified skills
232 recipe_subset dict;
233 for( const auto &r : recipe_dict ) {
234 if( opts.empty() || std::any_of( opts.begin(), opts.end(), [&r]( const std::string & s ) {
235 if( r.second.skill_used == skill_id( s ) && r.second.difficulty > 0 ) {
236 return true;
237 }
238 const auto iter = r.second.required_skills.find( skill_id( s ) );
239 return iter != r.second.required_skills.end() && iter->second > 0;
240 } ) ) {
241 dict.include( &r.second );
242 }
243 }
244
245 // only consider skills that are required by at least one recipe
246 std::vector<Skill> sk;
247 std::copy_if( Skill::skills.begin(), Skill::skills.end(),
248 std::back_inserter( sk ), [&dict]( const Skill & s ) {
249 return std::any_of( dict.begin(), dict.end(), [&s]( const recipe * r ) {
250 return r->skill_used == s.ident() ||
251 r->required_skills.find( s.ident() ) != r->required_skills.end();
252 } );
253 } );
254
255 header = { "Result" };
256
257 for( const auto &e : sk ) {
258 header.push_back( e.ident().str() );
259 }
260
261 for( const recipe *e : dict ) {
262 std::vector<std::string> r;
263 r.push_back( e->result_name() );
264 for( const auto &s : sk ) {
265 if( e->skill_used == s.ident() ) {
266 r.push_back( std::to_string( e->difficulty ) );
267 } else {
268 auto iter = e->required_skills.find( s.ident() );
269 r.push_back( std::to_string( iter != e->required_skills.end() ? iter->second : 0 ) );
270 }
271 }
272 rows.push_back( r );
273 }
274
275 } else if( what == "VEHICLE" ) {
276 header = {
277 "Name", "Weight (empty)", "Weight (fueled)",
278 "Max velocity (mph)", "Safe velocity (mph)", "Acceleration (mph/turn)",
279 "Aerodynamics coeff", "Rolling coeff", "Static Drag", "Offroad %"
280 };
281 auto dump = [&rows]( const vproto_id & obj ) {
282 vehicle veh_empty( obj, 0, 0 );
283 vehicle veh_fueled( obj, 100, 0 );
284
285 std::vector<std::string> r;
286 r.push_back( veh_empty.name );
287 r.push_back( std::to_string( to_kilogram( veh_empty.total_mass() ) ) );
288 r.push_back( std::to_string( to_kilogram( veh_fueled.total_mass() ) ) );
289 r.push_back( std::to_string( veh_fueled.max_velocity() / 100 ) );
290 r.push_back( std::to_string( veh_fueled.safe_velocity() / 100 ) );
291 r.push_back( std::to_string( veh_fueled.acceleration() / 100 ) );
292 r.push_back( std::to_string( veh_fueled.coeff_air_drag() ) );
293 r.push_back( std::to_string( veh_fueled.coeff_rolling_drag() ) );
294 r.push_back( std::to_string( veh_fueled.static_drag( false ) ) );
295 r.push_back( std::to_string( static_cast<int>( 50 *
296 veh_fueled.k_traction( veh_fueled.wheel_area() ) ) ) );
297 rows.push_back( r );
298 };
299 for( auto &e : vehicle_prototype::get_all() ) {
300 dump( e );
301 }
302
303 } else if( what == "VPART" ) {
304 header = {
305 "Name", "Location", "Weight", "Size"
306 };
307 auto dump = [&rows]( const vpart_info & obj ) {
308 std::vector<std::string> r;
309 r.push_back( obj.name() );
310 r.push_back( obj.location );
311 int w = std::ceil( to_gram( item( obj.item ).weight() ) / 1000.0 );
312 r.push_back( std::to_string( w ) );
313 r.push_back( std::to_string( obj.size / units::legacy_volume_factor ) );
314 rows.push_back( r );
315 };
316 for( const auto &e : vpart_info::all() ) {
317 dump( e.second );
318 }
319
320 } else {
321 std::cerr << "unknown argument: " << what << std::endl;
322 return false;
323 }
324
325 rows.erase( std::remove_if( rows.begin(), rows.end(), []( const std::vector<std::string> &e ) {
326 return e.empty();
327 } ), rows.end() );
328
329 if( scol >= 0 ) {
330 std::sort( rows.begin(), rows.end(), [&scol]( const std::vector<std::string> &lhs,
331 const std::vector<std::string> &rhs ) {
332 return localized_compare( lhs[ scol ], rhs[ scol ] );
333 } );
334 }
335
336 rows.erase( std::unique( rows.begin(), rows.end() ), rows.end() );
337
338 switch( mode ) {
339 case dump_mode::TSV:
340 rows.insert( rows.begin(), header );
341 for( const auto &r : rows ) {
342 // NOLINTNEXTLINE(cata-text-style): using tab to align the output
343 std::copy( r.begin(), r.end() - 1, std::ostream_iterator<std::string>( std::cout, "\t" ) );
344 std::cout << r.back() << "\n";
345 }
346 break;
347
348 case dump_mode::HTML:
349 std::cout << "<table>";
350
351 std::cout << "<thead>";
352 std::cout << "<tr>";
353 for( const auto &col : header ) {
354 std::cout << "<th>" << col << "</th>";
355 }
356 std::cout << "</tr>";
357 std::cout << "</thead>";
358
359 std::cout << "<tdata>";
360 for( const auto &r : rows ) {
361 std::cout << "<tr>";
362 for( const auto &col : r ) {
363 std::cout << "<td>" << col << "</td>";
364 }
365 std::cout << "</tr>";
366 }
367 std::cout << "</tdata>";
368
369 std::cout << "</table>";
370 break;
371 }
372
373 return true;
374}
body_part get_body_part_token(const std::string &id)
Returns the matching body_part token from the corresponding body_part string.
Definition: bodypart.cpp:180
body_part
Definition: bodypart.h:39
std::string to_string(const time_duration &d)
Returns a string showing a duration.
Definition: calendar.cpp:327
Definition: skill.h:33
static std::vector< Skill > skills
Definition: skill.h:49
const skill_id & ident() const
Definition: skill.h:65
units::mass weight(bool include_contents=true, bool integral=false) const
Definition: item.cpp:4958
void put_in(const item &payload)
Puts the given item into this one, no checks are performed.
Definition: item.cpp:995
item & ammo_set(const itype_id &ammo, int qty=-1)
Filter setting the ammo for this instance Any existing ammo is removed.
Definition: item.cpp:590
std::set< constrecipe * >::const_iterator begin() const
std::set< constrecipe * >::const_iterator end() const
void include(const recipe *r, int custom_difficulty=-1)
Include a recipe to the subset.
Definition: recipe.h:35
An NPC with standard stats.
Definition: npc.h:1363
static const std::map< vitamin_id, vitamin > & all()
Get all currently loaded vitamins.
Definition: vitamin.cpp:98
static const std::map< vpart_id, vpart_info > & all()
Definition: veh_type.cpp:695
static const std::string flag_VARSIZE("VARSIZE")
std::unique_ptr< Item_factory > item_controller
void transform(player &p, const tripoint &pos)
Transform the examined object into the object specified by its transforms_into property.
Definition: iexamine.cpp:1641
void load_core_bn_modfiles()
Load & finalize modlist that consists of single vanilla BN core "mod".
Definition: init.cpp:863
int gun_engagement_moves(const Character &who, const item &gun, int target=0, int start=MAX_RECOIL)
How many moves does it take to aim gun to the target accuracy.
Definition: ranged.cpp:583
static constexpr volume legacy_volume_factor
Definition: units_volume.h:50
constexpr value_type to_gram(const quantity< value_type, mass_in_milligram_tag > &v)
Definition: units_mass.h:68
constexpr value_type to_kilogram(const quantity< value_type, mass_in_milligram_tag > &v)
Definition: units_mass.h:74
std::string enumerate_as_string(const _Container &values, enumeration_conjunction conj=enumeration_conjunction::and_)
Definition: output.h:637
recipe_dictionary recipe_dict
float total_damage() const
Definition: damage.cpp:75
std::vector< damage_unit >::iterator begin()
Definition: damage.cpp:120
bool empty() const
Definition: damage.cpp:88
Default (or randomized) charges except if counted by charges then only one charge.
Definition: item.h:231
Definition: itype.h:836
static std::vector< vproto_id > get_all()
Definition: veh_type.cpp:1157

References vitamin::all(), item::ammo_capacity(), item::ammo_default(), item::ammo_set(), damage_instance::begin(), item::covers(), damage_instance::empty(), enumerate_as_string(), flag_VARSIZE(), g, get_body_part_token(), itype::gun, ranged::gun_engagement_moves(), item::has_flag(), Skill::ident(), recipe_subset::include(), item_controller, itype_id, units::legacy_volume_factor, init::load_core_bn_modfiles(), anonymous_namespace{overmap_location.cpp}::locations, item::magazine_default(), item::magazine_integral(), none, num_bp, item::put_in(), recipe_dict, item::set_flag(), Skill::skills, units::to_gram(), to_string(), damage_instance::total_damage(), iexamine::transform(), calendar::turn, and item::type.

◆ events()

event_bus & game::events ( )

Definition at line 2717 of file game.cpp.

2718{
2719 return *event_bus_ptr;
2720}
pimpl< event_bus > event_bus_ptr
Definition: game.h:952

References event_bus_ptr.

Referenced by cleanup_at_end(), and game().

◆ exam_vehicle()

void game::exam_vehicle ( vehicle veh,
point  cp = point_zero 
)

open vehicle interaction screen

Definition at line 4992 of file game.cpp.

4993{
4994 if( veh.magic ) {
4995 add_msg( m_info, _( "This is your %s" ), veh.name );
4996 return;
4997 }
4998 auto act = veh_interact::run( veh, c );
4999 if( act ) {
5000 u.moves = 0;
5002 }
5003}
static player_activity run(vehicle &veh, point p)
bool magic
Definition: vehicle.h:1891
constexpr double c
Definition: magic.cpp:1032
activity_id act
Definition: sounds.cpp:75

References _, act, add_msg(), Character::assign_activity(), c, m_info, vehicle::magic, Creature::moves, vehicle::name, veh_interact::run(), and u.

◆ examine() [1/2]

void game::examine ( )
private

Definition at line 5383 of file game.cpp.

5384{
5385 // if we are driving a vehicle, examine the
5386 // current tile without asking.
5387 const optional_vpart_position vp = m.veh_at( u.pos() );
5388 if( vp && vp->vehicle().player_in_control( u ) ) {
5389 examine( u.pos() );
5390 return;
5391 }
5392
5393 const std::optional<tripoint> examp_ = choose_adjacent_highlight( _( "Examine where?" ),
5394 _( "There is nothing that can be examined nearby." ),
5395 ACTION_EXAMINE, false );
5396 if( !examp_ ) {
5397 return;
5398 }
5399 u.manual_examine = true;
5400 examine( *examp_ );
5401 u.manual_examine = false;
5402}
std::optional< tripoint > choose_adjacent_highlight(const std::string &message, const std::string &failure_message, const action_id action, bool allow_vertical)
Request player input of adjacent tile with highlighting, possibly on different z-level.
Definition: action.cpp:995
@ ACTION_EXAMINE
Examine or pick up items from adjacent square.
Definition: action.h:101
void examine()
Definition: game.cpp:5383
bool manual_examine
Definition: player.h:249

References _, ACTION_EXAMINE, choose_adjacent_highlight(), examine(), m, player::manual_examine, Character::pos(), u, and map::veh_at().

Referenced by examine(), and handle_action().

◆ examine() [2/2]

void game::examine ( const tripoint p)
private

Definition at line 5471 of file game.cpp.

5472{
5473 if( disable_robot( examp ) ) {
5474 return;
5475 }
5476
5477 Creature *c = critter_at( examp );
5478 if( c != nullptr ) {
5479 monster *mon = dynamic_cast<monster *>( c );
5480 if( mon != nullptr ) {
5481 add_msg( _( "There is a %s." ), mon->get_name() );
5482 if( mon->has_effect( effect_pet ) && !u.is_mounted() ) {
5483 if( monexamine::pet_menu( *mon ) ) {
5484 return;
5485 }
5486 } else if( mon->has_flag( MF_RIDEABLE_MECH ) && !mon->has_effect( effect_pet ) ) {
5487 if( monexamine::mech_hack( *mon ) ) {
5488 return;
5489 }
5490 } else if( mon->has_flag( MF_PAY_BOT ) ) {
5491 if( monexamine::pay_bot( *mon ) ) {
5492 return;
5493 }
5494 } else if( mon->attitude_to( u ) == Creature::A_FRIENDLY && !u.is_mounted() ) {
5495 if( monexamine::mfriend_menu( *mon ) ) {
5496 return;
5497 }
5498 }
5499 } else if( u.is_mounted() ) {
5500 add_msg( m_warning, _( "You cannot do that while mounted." ) );
5501 }
5502 npc *np = dynamic_cast<npc *>( c );
5503 if( np != nullptr && !u.is_mounted() ) {
5504 if( npc_menu( *np ) ) {
5505 return;
5506 }
5507 } else if( np != nullptr && u.is_mounted() ) {
5508 add_msg( m_warning, _( "You cannot do that while mounted." ) );
5509 }
5510 }
5511
5512 const optional_vpart_position vp = m.veh_at( examp );
5513 if( vp && u.is_mounted() ) {
5514 if( !u.mounted_creature->has_flag( MF_RIDEABLE_MECH ) ) {
5515 add_msg( m_warning, _( "You cannot interact with a vehicle while mounted." ) );
5516 } else {
5517 vp->vehicle().interact_with( examp, vp->part_index() );
5518 return;
5519 }
5520 } else if( vp && !u.is_mounted() ) {
5521 vp->vehicle().interact_with( examp, vp->part_index() );
5522 return;
5523 }
5524
5525 if( m.has_flag( "CONSOLE", examp ) && !u.is_mounted() ) {
5526 use_computer( examp );
5527 return;
5528 } else if( m.has_flag( "CONSOLE", examp ) && u.is_mounted() ) {
5529 add_msg( m_warning, _( "You cannot use a console while mounted." ) );
5530 }
5531 const furn_t &xfurn_t = m.furn( examp ).obj();
5532 const ter_t &xter_t = m.ter( examp ).obj();
5533
5534 const tripoint player_pos = u.pos();
5535
5536 if( m.has_furn( examp ) && !u.is_mounted() ) {
5537 xfurn_t.examine( u, examp );
5538 } else if( m.has_furn( examp ) && u.is_mounted() ) {
5539 add_msg( m_warning, _( "You cannot do that while mounted." ) );
5540 } else {
5541 if( !u.is_mounted() ) {
5542 xter_t.examine( u, examp );
5543 } else if( u.is_mounted() && xter_t.examine == &iexamine::none ) {
5544 xter_t.examine( u, examp );
5545 } else {
5546 add_msg( m_warning, _( "You cannot do that while mounted." ) );
5547 }
5548 }
5549
5550 // Did the player get moved? Bail out if so; our examp probably
5551 // isn't valid anymore.
5552 if( player_pos != u.pos() ) {
5553 return;
5554 }
5555
5556 bool none = true;
5557 if( xter_t.examine != &iexamine::none || xfurn_t.examine != &iexamine::none ) {
5558 none = false;
5559 }
5560
5561 if( !m.tr_at( examp ).is_null() && !u.is_mounted() ) {
5562 iexamine::trap( u, examp );
5563 } else if( !m.tr_at( examp ).is_null() && u.is_mounted() ) {
5564 add_msg( m_warning, _( "You cannot do that while mounted." ) );
5565 }
5566
5567 // In case of teleport trap or somesuch
5568 if( player_pos != u.pos() ) {
5569 return;
5570 }
5571
5572 // Feedback for fire lasting time, this can be judged while mounted
5573 const std::string fire_fuel = get_fire_fuel_string( examp );
5574 if( !fire_fuel.empty() ) {
5575 add_msg( fire_fuel );
5576 }
5577
5578 if( m.has_flag( "SEALED", examp ) ) {
5579 if( none ) {
5580 if( m.has_flag( "UNSTABLE", examp ) ) {
5581 add_msg( _( "The %s is too unstable to remove anything." ), m.name( examp ) );
5582 } else {
5583 add_msg( _( "The %s is firmly sealed." ), m.name( examp ) );
5584 }
5585 }
5586 } else {
5587 //examp has no traps, is a container and doesn't have a special examination function
5588 if( m.tr_at( examp ).is_null() && m.i_at( examp ).empty() &&
5589 m.has_flag( "CONTAINER", examp ) && none ) {
5590 add_msg( _( "It is empty." ) );
5591 } else if( ( m.has_flag( TFLAG_FIRE_CONTAINER, examp ) &&
5592 xfurn_t.examine == &iexamine::fireplace ) ||
5593 xfurn_t.examine == &iexamine::workbench ||
5594 xfurn_t.examine == &iexamine::transform ) {
5595 return;
5596 } else {
5598 if( !u.is_mounted() ) {
5599 pickup::pick_up( examp, 0 );
5600 }
5601 }
5602 }
5603}
shared_ptr_fast< monster > mounted_creature
Definition: character.h:1613
@ A_FRIENDLY
Definition: creature.h:169
void use_computer(const tripoint &p)
Checks to see if a player can use a computer (not illiterate, etc.) and uses if able.
Definition: game.cpp:4503
bool disable_robot(const tripoint &p)
If there is a robot (that can be disabled), query the player and try to disable it.
Definition: game.cpp:8633
bool npc_menu(npc &who)
Returns true if the menu handled stuff and player shouldn't do anything else.
Definition: game.cpp:5274
bool empty() const
Definition: item_stack.cpp:15
bool has_furn(const tripoint &p) const
Definition: map.cpp:1407
const trap & tr_at(const tripoint &p) const
Definition: map.cpp:5236
ter_id ter(const tripoint &p) const
Definition: map.cpp:1562
Attitude attitude_to(const Creature &other) const override
Attitude (of this creature) towards another creature.
Definition: monster.cpp:1045
std::string get_name() const override
Definition: monster.cpp:484
static std::string get_fire_fuel_string(const tripoint &examp)
Definition: game.cpp:5404
@ TFLAG_FIRE_CONTAINER
Definition: mapdata.h:293
void fireplace(player &p, const tripoint &examp)
Definition: iexamine.cpp:2918
void workbench(player &p, const tripoint &examp)
Definition: iexamine.cpp:6196
void none(player &p, const tripoint &examp)
Nothing player can interact with here.
Definition: iexamine.cpp:252
void trap(player &p, const tripoint &examp)
Definition: iexamine.cpp:3817
bool pet_menu(monster &z)
Definition: monexamine.cpp:67
bool mech_hack(monster &z)
Definition: monexamine.cpp:433
bool mfriend_menu(monster &z)
Definition: monexamine.cpp:507
bool pay_bot(monster &z)
Definition: monexamine.cpp:466
void pick_up(const tripoint &p, int min, from_where get_items_from=prompt)
Pick up items; 'g' or ',' or via examine()
Definition: pickup.cpp:575
iexamine_function examine
Definition: mapdata.h:402
Definition: mapdata.h:461
bool is_null() const
Whether this is the null-traps, aka no trap at all.
Definition: trap.cpp:245

References _, Creature::A_FRIENDLY, add_msg(), monster::attitude_to(), c, critter_at(), disable_robot(), effect_pet, item_stack::empty(), map_data_common_t::examine, iexamine::fireplace(), map::furn(), get_fire_fuel_string(), monster::get_name(), Creature::has_effect(), map::has_flag(), monster::has_flag(), map::has_furn(), map::i_at(), Character::is_mounted(), trap::is_null(), m, m_warning, monexamine::mech_hack(), MF_PAY_BOT, MF_RIDEABLE_MECH, monexamine::mfriend_menu(), Character::mounted_creature, map::name(), none, iexamine::none(), npc_menu(), int_id< T >::obj(), monexamine::pay_bot(), monexamine::pet_menu(), pickup::pick_up(), Character::pos(), sounds::process_sound_markers(), map::ter(), TFLAG_FIRE_CONTAINER, map::tr_at(), iexamine::transform(), iexamine::trap(), u, use_computer(), map::veh_at(), and iexamine::workbench().

◆ extended_description()

void game::extended_description ( const tripoint p)

Long description of (visible) things at tile.

Definition at line 51 of file descriptions.cpp.

52{
54 const int top = 3;
55 int width = 0;
56 catacurses::window w_head;
57 catacurses::window w_main;
58 ui.on_screen_resize( [&]( ui_adaptor & ui ) {
59 const int left = 0;
60 const int right = TERMX;
61 const int bottom = TERMY;
62 width = right - left;
63 const int height = bottom - top;
64 w_head = catacurses::newwin( top, TERMX, point_zero );
65 w_main = catacurses::newwin( height, width, point( left, top ) );
66 ui.position( point_zero, point( TERMX, TERMY ) );
67 } );
68 ui.mark_resize();
69
70 // Default to critter (if any), furniture (if any), then terrain.
72 if( seen_critter( *this, p ) != nullptr ) {
74 } else if( get_map().has_furn( p ) ) {
76 }
77
78 std::string action;
79 input_context ctxt( "EXTENDED_DESCRIPTION" );
80 ctxt.register_action( "CREATURE" );
81 ctxt.register_action( "FURNITURE" );
82 ctxt.register_action( "TERRAIN" );
83 ctxt.register_action( "CONFIRM" );
84 ctxt.register_action( "QUIT" );
85 ctxt.register_action( "HELP_KEYBINDINGS" );
86
87 ui.on_redraw( [&]( const ui_adaptor & ) {
88 werase( w_head );
90 _( "[%s] describe creatures, [%s] describe furniture, "
91 "[%s] describe terrain, [%s] close." ),
92 ctxt.get_desc( "CREATURE" ), ctxt.get_desc( "FURNITURE" ),
93 ctxt.get_desc( "TERRAIN" ), ctxt.get_desc( "QUIT" ) );
94
95 // Set up line drawings
96 for( int i = 0; i < TERMX; i++ ) {
97 mvwputch( w_head, point( i, top - 1 ), c_white, LINE_OXOX );
98 }
99
100 wnoutrefresh( w_head );
101
102 std::string desc;
103 // Allow looking at invisible tiles - player may want to examine hallucinations etc.
104 switch( cur_target ) {
106 const Creature *critter = seen_critter( *this, p );
107 if( critter != nullptr ) {
108 desc = critter->extended_description();
109 } else {
110 desc = _( "You do not see any creature here." );
111 }
112 }
113 break;
115 if( !u.sees( p ) || !m.has_furn( p ) ) {
116 desc = _( "You do not see any furniture here." );
117 } else {
118 const furn_id fid = m.furn( p );
119 if( display_mod_source ) {
120 const std::string mod_src = enumerate_as_string( fid->src.begin(),
121 fid->src.end(), []( const std::pair<furn_str_id, mod_id> &source ) {
122 return string_format( "'%s'", source.second->name() );
124 desc = string_format( _( "Origin: %s\n" ), mod_src );
125 }
126 if( display_object_ids ) {
127 desc += colorize( string_format( "[%s]\n", fid.id() ), c_light_blue );
128 }
129 desc += fid.obj().extended_description();
130 }
131 break;
133 if( !u.sees( p ) ) {
134 desc = _( "You can't see the terrain here." );
135 } else {
136 const ter_id tid = m.ter( p );
137 if( display_mod_source ) {
138 const std::string mod_src = enumerate_as_string( tid->src.begin(),
139 tid->src.end(), []( const std::pair<ter_str_id, mod_id> &source ) {
140 return string_format( "'%s'", source.second->name() );
142 desc = string_format( _( "Origin: %s\n" ), mod_src );
143 }
144 if( display_object_ids ) {
145 desc += colorize( string_format( "[%s]\n", tid.id() ), c_light_blue );
146 }
147 desc += tid.obj().extended_description();
148 }
149 break;
150 }
151
152 std::string signage = m.get_signage( p );
153 if( !signage.empty() ) {
154 // NOLINTNEXTLINE(cata-text-style): the question mark does not end a sentence
155 desc += u.has_trait( trait_ILLITERATE ) ? _( "\nSign: ???" ) : string_format( _( "\nSign: %s" ),
156 signage );
157 }
158
159 werase( w_main );
160 fold_and_print_from( w_main, point_zero, width, 0, c_light_gray, desc );
161 wnoutrefresh( w_main );
162 } );
163
164 do {
166 action = ctxt.handle_input();
167 if( action == "CREATURE" ) {
168 cur_target = description_target::creature;
169 } else if( action == "FURNITURE" ) {
171 } else if( action == "TERRAIN" ) {
172 cur_target = description_target::terrain;
173 }
174 } while( action != "CONFIRM" && action != "QUIT" );
175}
bool display_object_ids
Display internal IDs for items, furniture, terrain and monsters.
bool display_mod_source
Display mod source for items, furniture, terrain and monsters.
virtual std::string extended_description() const =0
const string_id< T > & id() const
Definition: ammo_effect.cpp:33
std::string get_signage(const tripoint &p) const
Definition: map.cpp:4098
std::string colorize(const std::string &text, const nc_color &color)
Definition: color.cpp:669
static const trait_id trait_ILLITERATE("ILLITERATE")
static const Creature * seen_critter(const game &g, const tripoint &p)
description_target
int fold_and_print_from(const catacurses::window &w, point begin, int width, int begin_line, const nc_color &base_color, const std::string &text)
Like fold_and_print, but starts the output with the N-th line of the folded string.
Definition: output.cpp:311
std::vector< std::pair< furn_str_id, mod_id > > src
Definition: mapdata.h:498
std::string extended_description() const
std::vector< std::pair< ter_str_id, mod_id > > src
Definition: mapdata.h:463

References _, action, arrow, c_light_blue, c_light_gray, c_white, colorize(), creature, display_mod_source, display_object_ids, enumerate_as_string(), map_data_common_t::extended_description(), Creature::extended_description(), fold_and_print_from(), map::furn(), furniture, input_context::get_desc(), get_map, map::get_signage(), input_context::handle_input(), map::has_furn(), Character::has_trait(), int_id< T >::id(), left, LINE_OXOX, m, mvwprintz(), mvwputch(), catacurses::newwin(), int_id< T >::obj(), point_zero, ui_manager::redraw(), input_context::register_action(), right, seen_critter(), Character::sees(), ter_t::src, furn_t::src, string_format(), map::ter(), TERMX, TERMY, terrain, trait_ILLITERATE, u, catacurses::werase(), and catacurses::wnoutrefresh().

Referenced by look_around().

◆ find_nearby_items()

std::vector< map_item_stack > game::find_nearby_items ( int  iRadius)
private

Definition at line 6927 of file game.cpp.

6928{
6929 std::map<std::string, map_item_stack> temp_items;
6930 std::vector<map_item_stack> ret;
6931 std::vector<std::string> item_order;
6932
6933 if( u.is_blind() ) {
6934 return ret;
6935 }
6936
6937 int range = fov_3d ? ( fov_3d_z_range * 2 ) + 1 : 1;
6938 int center_z = u.pos().z;
6939
6940 for( int i = 1; i <= range; i++ ) {
6941 int z = i % 2 ? center_z - i / 2 : center_z + i / 2;
6942 for( auto &points_p_it : closest_points_first( {u.pos().xy(), z}, iRadius ) ) {
6943 if( points_p_it.y >= u.posy() - iRadius && points_p_it.y <= u.posy() + iRadius &&
6944 u.sees( points_p_it ) &&
6945 m.sees_some_items( points_p_it, u ) ) {
6946
6947 for( auto &elem : m.i_at( points_p_it ) ) {
6948 const std::string name = elem.tname();
6949 const tripoint relative_pos = points_p_it - u.pos();
6950
6951 if( std::find( item_order.begin(), item_order.end(), name ) == item_order.end() ) {
6952 item_order.push_back( name );
6953 temp_items[name] = map_item_stack( &elem, relative_pos );
6954 } else {
6955 temp_items[name].add_at_pos( &elem, relative_pos );
6956 }
6957 }
6958 }
6959 }
6960 }
6961
6962 for( auto &elem : item_order ) {
6963 ret.push_back( temp_items[elem] );
6964 }
6965
6966 return ret;
6967}
int fov_3d_z_range
3D FoV range, in Z levels, in both directions.
bool fov_3d
3D FoV enabled/disabled.
@ range
Definition: character.h:104
bool is_blind() const
Returns true if the player isn't able to see.
Definition: character.cpp:6263
std::vector< coords::coord_point< Point, Origin, Scale > > closest_points_first(const coords::coord_point< Point, Origin, Scale > &loc, int min_dist, int max_dist)
Definition: coordinates.h:596

References closest_points_first(), detail::find(), fov_3d, fov_3d_z_range, map::i_at(), Character::is_blind(), m, om_direction::name(), Character::pos(), Character::posy(), range, cata::hash64_detail::ret, Character::sees(), map::sees_some_items(), u, and tripoint::z.

Referenced by list_items_monsters().

◆ find_npc()

npc * game::find_npc ( character_id  id)

Find the npc with the given ID.

Returns NULL if the npc could not be found. Searches all loaded overmaps.

Definition at line 1879 of file game.cpp.

1880{
1881 return overmap_buffer.find_npc( id ).get();
1882}

References overmapbuffer::find_npc(), and overmap_buffer.

Referenced by critter_by_id().

◆ find_or_make_stairs()

std::optional< tripoint > game::find_or_make_stairs ( map mp,
int  z_after,
bool &  rope_ladder,
bool  peeking 
)

Returns the other end of the stairs (if any).

May query, affect u etc.

Definition at line 10421 of file game.cpp.

10423{
10424 const int omtilesz = SEEX * 2;
10425 real_coords rc( m.getabs( point( u.posx(), u.posy() ) ) );
10426 tripoint omtile_align_start( m.getlocal( rc.begin_om_pos() ), z_after );
10427 tripoint omtile_align_end( omtile_align_start + point( -1 + omtilesz, -1 + omtilesz ) );
10428
10429 // Try to find the stairs.
10430 std::optional<tripoint> stairs;
10431 int best = INT_MAX;
10432 const int movez = z_after - get_levz();
10433 const bool going_down_1 = movez == -1;
10434 const bool going_up_1 = movez == 1;
10435 // If there are stairs on the same x and y as we currently are, use those
10436 if( going_down_1 && mp.has_flag( TFLAG_GOES_UP, u.pos() + tripoint_below ) ) {
10437 stairs.emplace( u.pos() + tripoint_below );
10438 }
10439 if( going_up_1 && mp.has_flag( TFLAG_GOES_DOWN, u.pos() + tripoint_above ) ) {
10440 stairs.emplace( u.pos() + tripoint_above );
10441 }
10442 // We did not find stairs directly above or below, so search the map for them
10443 if( !stairs.has_value() ) {
10444 for( const tripoint &dest : m.points_in_rectangle( omtile_align_start, omtile_align_end ) ) {
10445 if( rl_dist( u.pos(), dest ) <= best &&
10446 ( ( going_down_1 && mp.has_flag( TFLAG_GOES_UP, dest ) ) ||
10447 ( going_up_1 && ( mp.has_flag( TFLAG_GOES_DOWN, dest ) ||
10448 mp.ter( dest ) == t_manhole_cover ) ) ||
10449 ( ( movez == 2 || movez == -2 ) && mp.ter( dest ) == t_elevator ) ) ) {
10450 stairs.emplace( dest );
10451 best = rl_dist( u.pos(), dest );
10452 }
10453 }
10454 }
10455
10456 if( stairs.has_value() ) {
10457 if( Creature *blocking_creature = critter_at( stairs.value() ) ) {
10458 npc *guy = dynamic_cast<npc *>( blocking_creature );
10459 monster *mon = dynamic_cast<monster *>( blocking_creature );
10460 bool would_move = ( guy && !guy->is_enemy() ) || ( mon && mon->friendly == -1 );
10461 bool can_displace = find_empty_spot_nearby( *stairs ).has_value();
10462 std::string cr_name = blocking_creature->get_name();
10463 std::string msg;
10464 if( guy ) {
10465 //~ %s is the name of hostile NPC
10466 msg = string_format( _( "%s is in the way!" ), cr_name );
10467 } else {
10468 //~ %s is some monster
10469 msg = string_format( _( "There's a %s in the way!" ), cr_name );
10470 }
10471
10472 if( ( peeking && !would_move ) || !can_displace || ( !would_move && !query_yn(
10473 //~ %s is a warning about monster/hostile NPC in the way, e.g. "There's a zombie in the way!"
10474 _( "%s Attempt to push past? You may have to fight your way back up." ), msg ) ) ) {
10475 add_msg( msg );
10476 return std::nullopt;
10477 }
10478 }
10479 return stairs;
10480 }
10481
10482 // No stairs found! Try to make some
10483 rope_ladder = false;
10484 stairs.emplace( u.pos() );
10485 stairs->z = z_after;
10486 // Check the destination area for lava.
10487 if( mp.ter( *stairs ) == t_lava ) {
10488 if( movez < 0 &&
10489 !query_yn(
10490 _( "There is a LOT of heat coming out of there, even the stairs have melted away. Jump down? You won't be able to get back up." ) ) ) {
10491 return std::nullopt;
10492 } else if( movez > 0 &&
10493 !query_yn(
10494 _( "There is a LOT of heat coming out of there. Push through the half-molten rocks and ascend? You will not be able to get back down." ) ) ) {
10495 return std::nullopt;
10496 }
10497
10498 return stairs;
10499 }
10500
10501 if( movez > 0 ) {
10502 if( !mp.has_flag( "GOES_DOWN", *stairs ) ) {
10503 if( !query_yn( _( "You may be unable to return back down these stairs. Continue up?" ) ) ) {
10504 return std::nullopt;
10505 }
10506 }
10507 // Manhole covers need this to work
10508 // Maybe require manhole cover here and fail otherwise?
10509 return stairs;
10510 }
10511
10512 if( mp.impassable( *stairs ) ) {
10513 popup( _( "Halfway down, the way down becomes blocked off." ) );
10514 return std::nullopt;
10515 }
10516
10517 if( u.has_trait( trait_id( "WEB_RAPPEL" ) ) ) {
10518 if( query_yn( _( "There is a sheer drop halfway down. Web-descend?" ) ) ) {
10519 rope_ladder = true;
10520 if( ( rng( 4, 8 ) ) < u.get_skill_level( skill_dodge ) ) {
10521 add_msg( _( "You attach a web and dive down headfirst, flipping upright and landing on your feet." ) );
10522 } else {
10523 add_msg( _( "You securely web up and work your way down, lowering yourself safely." ) );
10524 }
10525 } else {
10526 return std::nullopt;
10527 }
10528 } else if( u.has_trait( trait_VINES2 ) || u.has_trait( trait_VINES3 ) ) {
10529 if( query_yn( _( "There is a sheer drop halfway down. Use your vines to descend?" ) ) ) {
10530 if( u.has_trait( trait_VINES2 ) ) {
10531 if( query_yn( _( "Detach a vine? It'll hurt, but you'll be able to climb back up…" ) ) ) {
10532 rope_ladder = true;
10533 add_msg( m_bad, _( "You descend on your vines, though leaving a part of you behind stings." ) );
10534 u.mod_pain( 5 );
10535 u.apply_damage( nullptr, bodypart_id( "torso" ), 5 );
10536 u.mod_stored_nutr( 10 );
10537 u.mod_thirst( 10 );
10538 } else {
10539 add_msg( _( "You gingerly descend using your vines." ) );
10540 }
10541 } else {
10542 add_msg( _( "You effortlessly lower yourself and leave a vine rooted for future use." ) );
10543 rope_ladder = true;
10544 u.mod_stored_nutr( 10 );
10545 u.mod_thirst( 10 );
10546 }
10547 } else {
10548 return std::nullopt;
10549 }
10550 } else if( u.has_amount( itype_grapnel, 1 ) ) {
10551 if( query_yn( _( "There is a sheer drop halfway down. Climb your grappling hook down?" ) ) ) {
10552 rope_ladder = true;
10554 } else {
10555 return std::nullopt;
10556 }
10557 } else if( u.has_amount( itype_rope_30, 1 ) ) {
10558 if( query_yn( _( "There is a sheer drop halfway down. Climb your rope down?" ) ) ) {
10559 rope_ladder = true;
10561 } else {
10562 return std::nullopt;
10563 }
10564 } else if( !query_yn( _( "There is a sheer drop halfway down. Jump?" ) ) ) {
10565 return std::nullopt;
10566 }
10567
10568 return stairs;
10569}
int_id< body_part_type > bodypart_id
Definition: bodypart.h:23
void mod_pain(int npain) override
Modifies a pain value by player traits before passing it to Creature::mod_pain()
Definition: character.cpp:761
void apply_damage(Creature *source, bodypart_id hurt, int dam, bool bypass_med=false) override
Actually hurt the player, hurts a body_part directly, no armor reduction.
Definition: character.cpp:8384
std::list< item > use_amount(itype_id it, int quantity, const std::function< bool(const item &)> &filter=return_true< item >)
Definition: character.cpp:9611
virtual void mod_thirst(int nthirst)
Definition: character.cpp:4428
virtual void mod_stored_nutr(int nnutr)
Definition: character.cpp:4318
int get_skill_level(const skill_id &ident) const
Definition: character.cpp:3340
tripoint getlocal(const tripoint &p) const
Inverse of getabs.
Definition: map.cpp:8388
tripoint_range< tripoint > points_in_rectangle(const tripoint &from, const tripoint &to) const
Definition: map.cpp:8723
bool is_enemy() const
Definition: npc.cpp:2064
static const trait_id trait_VINES2("VINES2")
static const skill_id skill_dodge("dodge")
static std::optional< tripoint > find_empty_spot_nearby(const tripoint &pos)
Definition: game.cpp:9957
static const itype_id itype_rope_30("rope_30")
static const itype_id itype_grapnel("grapnel")
static const trait_id trait_VINES3("VINES3")
ter_id t_manhole_cover
Definition: mapdata.cpp:722
ter_id t_lava
Definition: mapdata.cpp:697
ter_id t_elevator
Definition: mapdata.cpp:725
@ TFLAG_GOES_DOWN
Definition: mapdata.h:308
@ TFLAG_GOES_UP
Definition: mapdata.h:309
static constexpr tripoint tripoint_below
Definition: point.h:281
static constexpr tripoint tripoint_above
Definition: point.h:280

References _, add_msg(), Character::apply_damage(), real_coords::begin_om_pos(), critter_at(), find_empty_spot_nearby(), monster::friendly, get_levz(), Character::get_skill_level(), map::getabs(), map::getlocal(), visitable< T >::has_amount(), map::has_flag(), Character::has_trait(), map::impassable(), npc::is_enemy(), itype_grapnel, itype_rope_30, m, m_bad, Character::mod_pain(), Character::mod_stored_nutr(), Character::mod_thirst(), map::points_in_rectangle(), popup(), Character::pos(), Character::posx(), Character::posy(), query_yn(), rl_dist(), rng(), SEEX, skill_dodge, string_format(), t_elevator, t_lava, t_manhole_cover, map::ter(), TFLAG_GOES_DOWN, TFLAG_GOES_UP, trait_VINES2, trait_VINES3, tripoint_above, tripoint_below, u, and Character::use_amount().

Referenced by vertical_move().

◆ fling_creature()

void game::fling_creature ( Creature c,
const units::angle dir,
float  flvel,
bool  controlled = false 
)

Flings the input creature in the given direction.

Definition at line 9760 of file game.cpp.

9761{
9762 if( c == nullptr ) {
9763 debugmsg( "game::fling_creature invoked on null target" );
9764 return;
9765 }
9766
9767 if( c->is_dead_state() ) {
9768 // Flinging a corpse causes problems, don't enable without testing
9769 return;
9770 }
9771
9772 if( c->is_hallucination() ) {
9773 // Don't fling hallucinations
9774 return;
9775 }
9776
9777 bool thru = true;
9778 const bool is_u = ( c == &u );
9779 // Don't animate critters getting bashed if animations are off
9780 const bool animate = is_u || get_option<bool>( "ANIMATIONS" );
9781
9782 player *p = dynamic_cast<player *>( c );
9783
9784 tileray tdir( dir );
9785 int range = flvel / 10;
9786 tripoint pt = c->pos();
9787 tripoint prev_point = pt;
9788 bool force_next = false;
9789 tripoint next_forced;
9790 while( range > 0 ) {
9791 c->set_underwater( false );
9792 // TODO: Check whenever it is actually in the viewport
9793 // or maybe even just redraw the changed tiles
9794 bool seen = is_u || u.sees( *c ); // To avoid redrawing when not seen
9795 if( force_next ) {
9796 pt = next_forced;
9797 force_next = false;
9798 } else {
9799 tdir.advance();
9800 pt.x = c->posx() + tdir.dx();
9801 pt.y = c->posy() + tdir.dy();
9802 }
9803 float force = 0;
9804
9805 if( m.obstructed_by_vehicle_rotation( prev_point, pt ) ) {
9806 //We process the intervening tile on this iteration and then the current tile on the next
9807 next_forced = pt;
9808 force_next = true;
9809 if( one_in( 2 ) ) {
9810 pt.x = prev_point.x;
9811 } else {
9812 pt.y = prev_point.y;
9813 }
9814 }
9815
9816
9817 if( monster *const mon_ptr = critter_at<monster>( pt ) ) {
9818 monster &critter = *mon_ptr;
9819 // Approximate critter's "stopping power" with its max hp
9820 force = std::min<float>( 1.5f * critter.type->hp, flvel );
9821 const int damage = rng( force, force * 2.0f ) / 6;
9822 c->impact( damage, pt );
9823 // Multiply zed damage by 6 because no body parts
9824 const int zed_damage = std::max( 0,
9825 ( damage - critter.get_armor_bash( bodypart_id( "torso" ) ) ) * 6 );
9826 // TODO: Pass the "flinger" here - it's not the flung critter that deals damage
9827 critter.apply_damage( c, bodypart_id( "torso" ), zed_damage );
9828 critter.check_dead_state();
9829 if( !critter.is_dead() ) {
9830 thru = false;
9831 }
9832 } else if( m.impassable( pt ) ) {
9833 if( !m.veh_at( pt ).obstacle_at_part() ) {
9834 force = std::min<float>( m.bash_strength( pt ), flvel );
9835 } else {
9836 // No good way of limiting force here
9837 // Keep it 1 less than maximum to make the impact hurt
9838 // but to keep the target flying after it
9839 force = flvel - 1;
9840 }
9841 const int damage = rng( force, force * 2.0f ) / 9;
9842 c->impact( damage, pt );
9843 if( m.is_bashable( pt ) ) {
9844 // Only go through if we successfully make the tile passable
9845 m.bash( pt, flvel );
9846 thru = m.passable( pt );
9847 } else {
9848 thru = false;
9849 }
9850 }
9851
9852 // If the critter dies during flinging, moving it around causes debugmsgs
9853 if( c->is_dead_state() ) {
9854 return;
9855 }
9856
9857 flvel -= force;
9858 if( thru ) {
9859 if( p != nullptr ) {
9860 if( p->in_vehicle ) {
9861 m.unboard_vehicle( p->pos() );
9862 }
9863 // If we're flinging the player around, make sure the map stays centered on them.
9864 if( is_u ) {
9865 update_map( pt.x, pt.y );
9866 } else {
9867 p->setpos( pt );
9868 }
9869 } else if( !critter_at( pt ) ) {
9870 // Dying monster doesn't always leave an empty tile (blob spawning etc.)
9871 // Just don't setpos if it happens - next iteration will do so
9872 // or the monster will stop a tile before the unpassable one
9873 c->setpos( pt );
9874 }
9875 } else {
9876 // Don't zero flvel - count this as slamming both the obstacle and the ground
9877 // although at lower velocity
9878 break;
9879 }
9880 //Vehicle wall tiles don't count for range
9881 if( !force_next ) {
9882 range--;
9883 }
9884 prev_point = pt;
9885 if( animate && ( seen || u.sees( *c ) ) ) {
9890 }
9891 }
9892
9893 // Fall down to the ground - always on the last reached tile
9894 if( !m.has_flag( "SWIMMABLE", c->pos() ) ) {
9895 const trap_id trap_under_creature = m.tr_at( c->pos() ).loadid;
9896 // Didn't smash into a wall or a floor so only take the fall damage
9897 if( thru && trap_under_creature == tr_ledge ) {
9898 m.creature_on_trap( *c, false );
9899 } else {
9900 // Fall on ground
9901 int force = rng( flvel, flvel * 2 ) / 9;
9902 if( controlled ) {
9903 force = std::max( force / 2 - 5, 0 );
9904 }
9905 if( force > 0 ) {
9906 int dmg = c->impact( force, c->pos() );
9907 // TODO: Make landing damage the floor
9908 m.bash( c->pos(), dmg / 4, false, false, false );
9909 }
9910 // Always apply traps to creature i.e. bear traps, tele traps etc.
9911 m.creature_on_trap( *c, false );
9912 }
9913 } else {
9914 c->set_underwater( true );
9915 if( is_u ) {
9916 if( controlled ) {
9917 add_msg( _( "You dive into water." ) );
9918 } else {
9919 add_msg( m_warning, _( "You fall into water." ) );
9920 }
9921 }
9922 }
9923}
void setpos(const tripoint &p) override
Definition: character.h:815
void check_dead_state()
This function checks the creatures is_dead_state and (if true) calls die.
Definition: creature.cpp:1873
point update_map(player &p)
Definition: game.cpp:10648
void pump_events()
Resize & refresh if necessary, process all pending window events, and ignore keypresses.
int bash_strength(const tripoint &p, bool allow_floor=false) const
Returns max_str of the furniture or terrain at p.
Definition: map.cpp:2542
bool obstructed_by_vehicle_rotation(const tripoint &from, const tripoint &to) const
Checks if a rotated vehicle is blocking diagonal movement, tripoints must be adjacent.
Definition: map.cpp:6594
bash_results bash(const tripoint &p, int str, bool silent=false, bool destroy=false, bool bash_floor=false, const vehicle *bashing_vehicle=nullptr)
Returns a pair where first is whether anything was smashed and second is if it was destroyed.
Definition: map.cpp:3623
void unboard_vehicle(const vpart_reference &, Character *passenger, bool dead_passenger=false)
Definition: map.cpp:1145
bool is_bashable(const tripoint &p, bool allow_floor=false) const
Returns true if there is a bashable vehicle part or the furn/terrain is bashable at p.
Definition: map.cpp:2506
void creature_on_trap(Creature &critter, bool may_avoid=true)
Apply trap effects to the creature, similar to creature_in_field.
Definition: map.cpp:8600
bool passable(const tripoint &p) const
Definition: map.cpp:1864
int get_armor_bash(bodypart_id bp) const override
Definition: monster.cpp:1904
bool is_dead() const
Definition: monster.cpp:2814
void apply_damage(Creature *source, bodypart_id bp, int dam, bool bypass_med=false) override
Definition: monster.cpp:1685
std::optional< vpart_reference > obstacle_at_part() const
Definition: vehicle.cpp:2494
Definition: player.h:84
static const trap_str_id tr_ledge("tr_ledge")
void redraw_invalidated()
Redraw all invalidated windows without invalidating the top window.
Definition: ui_manager.cpp:394
int hp
Definition: mtype.h:270
trap_id loadid
Definition: trap.h:88
int y
Definition: point.h:137
int x
Definition: point.h:136

References _, add_msg(), tileray::advance(), monster::apply_damage(), map::bash(), map::bash_strength(), c, Creature::check_dead_state(), map::creature_on_trap(), critter_at(), debugmsg, tileray::dx(), tileray::dy(), monster::get_armor_bash(), map::has_flag(), mtype::hp, map::impassable(), Character::in_vehicle, inp_mngr, invalidate_main_ui_adaptor(), map::is_bashable(), monster::is_dead(), trap::loadid, m, m_warning, optional_vpart_position::obstacle_at_part(), map::obstructed_by_vehicle_rotation(), one_in(), map::passable(), Character::pos(), input_manager::pump_events(), range, ui_manager::redraw_invalidated(), refresh_display(), rng(), Character::sees(), Character::setpos(), map::tr_at(), tr_ledge, monster::type, u, map::unboard_vehicle(), update_map(), map::veh_at(), tripoint::x, and tripoint::y.

Referenced by moving_vehicle_dismount().

◆ forced_door_closing()

bool game::forced_door_closing ( const tripoint p,
const ter_id door_type,
int  bash_dmg 
)

Definition at line 5005 of file game.cpp.

5006{
5007 const auto valid_location = [&]( const tripoint & p ) {
5008 return g->is_empty( p );
5009 };
5010 const auto get_random_point = [&]() -> tripoint {
5011 if( auto pos = random_point( m.points_in_radius( p, 2 ), valid_location ) )
5012 {
5013 return p * 2 - ( *pos );
5014 } else
5015 {
5016 return p;
5017 }
5018 };
5019
5020 const std::string &door_name = door_type.obj().name();
5021 const tripoint kbp = get_random_point();
5022
5023 // can't pushback any creatures/items anywhere, that means the door can't close.
5024 const bool cannot_push = kbp == p;
5025 const bool can_see = u.sees( p );
5026
5027 player *npc_or_player = critter_at<player>( p, false );
5028 if( npc_or_player != nullptr ) {
5029 if( bash_dmg <= 0 ) {
5030 return false;
5031 }
5032 if( npc_or_player->is_npc() && can_see ) {
5033 add_msg( _( "The %1$s hits the %2$s." ), door_name, npc_or_player->name );
5034 } else if( npc_or_player->is_player() ) {
5035 add_msg( m_bad, _( "The %s hits you." ), door_name );
5036 }
5037 if( npc_or_player->activity ) {
5038 npc_or_player->cancel_activity();
5039 }
5040 // TODO: make the npc angry?
5041 npc_or_player->hitall( bash_dmg, 0, nullptr );
5042 if( cannot_push ) {
5043 return false;
5044 }
5045 // TODO implement who was closing the door and replace nullptr
5046 knockback( kbp, p, std::max( 1, bash_dmg / 10 ), -1, 1, nullptr );
5047 // TODO: perhaps damage/destroy the gate
5048 // if the npc was really big?
5049 }
5050 if( monster *const mon_ptr = critter_at<monster>( p ) ) {
5051 monster &critter = *mon_ptr;
5052 if( bash_dmg <= 0 ) {
5053 return false;
5054 }
5055 if( can_see ) {
5056 add_msg( _( "The %1$s hits the %2$s." ), door_name, critter.name() );
5057 }
5058 if( critter.type->size <= MS_SMALL ) {
5059 critter.die_in_explosion( nullptr );
5060 } else {
5061 critter.apply_damage( nullptr, bodypart_id( "torso" ), bash_dmg );
5062 critter.check_dead_state();
5063 }
5064 if( !critter.is_dead() && critter.type->size >= MS_HUGE ) {
5065 // big critters simply prevent the gate from closing
5066 // TODO: perhaps damage/destroy the gate
5067 // if the critter was really big?
5068 return false;
5069 }
5070 if( !critter.is_dead() ) {
5071 // Still alive? Move the critter away so the door can close
5072 if( cannot_push ) {
5073 return false;
5074 }
5075 // TODO implement who was closing the door and replace nullptr
5076 knockback( kbp, p, std::max( 1, bash_dmg / 10 ), -1, 1, nullptr );
5077 if( critter_at( p ) ) {
5078 return false;
5079 }
5080 }
5081 }
5082 if( const optional_vpart_position vp = m.veh_at( p ) ) {
5083 if( bash_dmg <= 0 ) {
5084 return false;
5085 }
5086 vp->vehicle().damage( vp->part_index(), bash_dmg );
5087 if( m.veh_at( p ) ) {
5088 // Check again in case all parts at the door tile
5089 // have been destroyed, if there is still a vehicle
5090 // there, the door can not be closed
5091 return false;
5092 }
5093 }
5094 if( bash_dmg < 0 && !m.i_at( p ).empty() ) {
5095 return false;
5096 }
5097 if( bash_dmg == 0 ) {
5098 for( auto &elem : m.i_at( p ) ) {
5099 if( elem.made_of( LIQUID ) ) {
5100 // Liquids are OK, will be destroyed later
5101 continue;
5102 } else if( elem.volume() < 250_ml ) {
5103 // Dito for small items, will be moved away
5104 continue;
5105 }
5106 // Everything else prevents the door from closing
5107 return false;
5108 }
5109 }
5110
5111 m.ter_set( p, door_type );
5112 if( m.has_flag( "NOITEM", p ) ) {
5113 map_stack items = m.i_at( p );
5114 for( map_stack::iterator it = items.begin(); it != items.end(); ) {
5115 if( it->made_of( LIQUID ) ) {
5116 it = items.erase( it );
5117 continue;
5118 }
5119 if( it->made_of( material_id( "glass" ) ) && one_in( 2 ) ) {
5120 if( can_see ) {
5121 add_msg( m_warning, _( "A %s shatters!" ), it->tname() );
5122 } else {
5123 add_msg( m_warning, _( "Something shatters!" ) );
5124 }
5125 it = items.erase( it );
5126 continue;
5127 }
5128 if( cannot_push ) {
5129 return false;
5130 }
5131 m.add_item_or_charges( kbp, *it );
5132 it = items.erase( it );
5133 }
5134 }
5135 return true;
5136}
int hitall(int dam, int vary, Creature *source)
Harms all body parts for dam, with armor reduction.
Definition: character.cpp:8661
void knockback(const tripoint &s, const tripoint &t, int force, int stun, int dam_mult, Creature *source)
Definition: game.cpp:4244
iterator erase(const_iterator it) override
Definition: map.cpp:153
bool ter_set(const tripoint &p, const ter_id &new_terrain)
Definition: map.cpp:1703
void die_in_explosion(Creature *source)
Definition: monster.cpp:1699
bool is_npc() const override
Definition: player.h:103
bool is_player() const override
Definition: player.h:93
@ MS_SMALL
Definition: creature.h:59
@ MS_HUGE
Definition: creature.h:62
@ LIQUID
Definition: enums.h:175
std::optional< tripoint > random_point(const map &m, const std::function< bool(const tripoint &)> &predicate)
Same as other random_point with a range enclosing all valid points of the map.
std::string name() const
Definition: mapdata.cpp:513
m_size size
Definition: mtype.h:262

References _, Character::activity, map::add_item_or_charges(), add_msg(), monster::apply_damage(), item_stack::begin(), Character::cancel_activity(), Creature::check_dead_state(), critter_at(), monster::die_in_explosion(), item_stack::empty(), item_stack::end(), map_stack::erase(), g, map::has_flag(), Character::hitall(), map::i_at(), monster::is_dead(), player::is_npc(), player::is_player(), knockback(), LIQUID, m, m_bad, m_warning, MS_HUGE, MS_SMALL, Character::name, map_data_common_t::name(), monster::name(), int_id< T >::obj(), one_in(), map::points_in_radius(), random_point(), Character::sees(), mtype::size, map::ter_set(), monster::type, u, and map::veh_at().

◆ gametype()

special_game_type game::gametype ( ) const

Definition at line 537 of file game.cpp.

538{
540}

References gamemode, and NONE.

◆ get_creature_if()

Creature * game::get_creature_if ( const std::function< bool(const Creature &)> &  pred)

Returns a creature matching a predicate.

Only living (not dead) creatures are checked. Returns nullptr if no creature matches the predicate. There is no guarantee which creature is returned when several creatures match.

Definition at line 12011 of file game.cpp.

12012{
12013 for( Creature &critter : all_creatures() ) {
12014 if( pred( critter ) ) {
12015 return &critter;
12016 }
12017 }
12018 return nullptr;
12019}

References all_creatures().

◆ get_creatures_if()

std::vector< Creature * > game::get_creatures_if ( const std::function< bool(const Creature &)> &  pred)

Returns all creatures matching a predicate.

Only living ( not dead ) creatures are checked ( and returned ). Returned pointers are never null.

Definition at line 11921 of file game.cpp.

11923{
11924 std::vector<Creature *> result;
11925 for( Creature &critter : all_creatures() ) {
11926 if( pred( critter ) ) {
11927 result.push_back( &critter );
11928 }
11929 }
11930 return result;
11931}

References all_creatures().

◆ get_cur_om()

overmap & game::get_cur_om ( ) const

The overmap which contains the center submap of the reality bubble.

Definition at line 11901 of file game.cpp.

11902{
11903 // The player is located in the middle submap of the map.
11905 const tripoint pos_om = sm_to_om_copy( sm );
11906 // TODO: fix point types
11907 return overmap_buffer.get( point_abs_om( pos_om.xy() ) );
11908}
tripoint get_abs_sub() const
return abs_sub
Definition: map.cpp:8404
overmap & get(const point_abs_om &)
Uses overmap coordinates, that means x and y are directly compared with the position of the overmap.
point sm_to_om_copy(point p)
coords::coord_point< point, coords::origin::abs, coords::om > point_abs_om
Definition: coordinates.h:483
static constexpr int HALF_MAPSIZE
constexpr scale sm
Definition: coordinates.h:31

References overmapbuffer::get(), map::get_abs_sub(), HALF_MAPSIZE, m, overmap_buffer, coords::sm, sm_to_om_copy(), and tripoint::xy().

Referenced by start_game().

◆ get_dangerous_tile()

std::vector< std::string > game::get_dangerous_tile ( const tripoint dest_loc) const

Definition at line 8717 of file game.cpp.

8718{
8719 std::vector<std::string> harmful_stuff;
8720 const auto fields_here = m.field_at( u.pos() );
8721 for( const auto &e : m.field_at( dest_loc ) ) {
8722 // warn before moving into a dangerous field except when already standing within a similar field
8723 if( u.is_dangerous_field( e.second ) && fields_here.find_field( e.first ) == nullptr ) {
8724 harmful_stuff.push_back( e.second.name() );
8725 }
8726 }
8727
8728 if( !u.is_blind() ) {
8729 const trap &tr = m.tr_at( dest_loc );
8730 const bool boardable = static_cast<bool>( m.veh_at( dest_loc ).part_with_feature( "BOARDABLE",
8731 true ) );
8732 // HACK: Hack for now, later ledge should stop being a trap
8733 // Note: in non-z-level mode, ledges obey different rules and so should be handled as regular traps
8734 if( tr.loadid == tr_ledge && m.has_zlevels() ) {
8735 if( !boardable ) {
8736 harmful_stuff.emplace_back( tr.name() );
8737 }
8738 } else if( tr.can_see( dest_loc, u ) && !tr.is_benign() && !boardable ) {
8739 harmful_stuff.emplace_back( tr.name() );
8740 }
8741
8742 static const std::set< body_part > sharp_bps = {
8745 };
8746
8747 const auto sharp_bp_check = [this]( body_part bp ) {
8748 return character_funcs::is_bp_immune_to( u, bp, { DT_CUT, 10 } );
8749 };
8750
8751 if( m.has_flag( "ROUGH", dest_loc ) && !m.has_flag( "ROUGH", u.pos() ) && !boardable &&
8752 ( u.get_armor_bash( bodypart_id( "foot_l" ) ) < 5 ||
8753 u.get_armor_bash( bodypart_id( "foot_r" ) ) < 5 ) ) {
8754 harmful_stuff.emplace_back( m.name( dest_loc ) );
8755 } else if( m.has_flag( "SHARP", dest_loc ) && !m.has_flag( "SHARP", u.pos() ) && !( u.in_vehicle ||
8756 m.veh_at( dest_loc ) ) &&
8757 u.dex_cur < 78 && !std::all_of( sharp_bps.begin(), sharp_bps.end(), sharp_bp_check ) ) {
8758 harmful_stuff.emplace_back( m.name( dest_loc ) );
8759 }
8760
8761 }
8762
8763 return harmful_stuff;
8764}
@ bp_foot_l
Definition: bodypart.h:50
@ bp_leg_r
Definition: bodypart.h:49
@ bp_eyes
Definition: bodypart.h:42
@ bp_hand_l
Definition: bodypart.h:46
@ bp_arm_l
Definition: bodypart.h:44
@ bp_leg_l
Definition: bodypart.h:48
@ bp_hand_r
Definition: bodypart.h:47
@ bp_head
Definition: bodypart.h:41
@ bp_torso
Definition: bodypart.h:40
@ bp_mouth
Definition: bodypart.h:43
@ bp_foot_r
Definition: bodypart.h:51
@ bp_arm_r
Definition: bodypart.h:45
int dex_cur
Definition: character.h:265
int get_armor_bash(bodypart_id bp) const override
Returns overall bashing resistance for the body_part.
Definition: character.cpp:6851
bool is_dangerous_field(const field_entry &entry) const
Returns true if the given field entry is dangerous to us.
Definition: creature.cpp:198
const field & field_at(const tripoint &p) const
Get the fields that are here.
Definition: map.cpp:5398
bool has_zlevels() const
Definition: map.h:1635
@ DT_CUT
Definition: damage.h:25
bool is_bp_immune_to(const Character &who, body_part bp, damage_unit dam)
Check if character's body part is immune to given damage.
Definition: trap.h:86
std::string name() const
Definition: trap.cpp:177
bool can_see(const tripoint &pos, const Character &p) const
Can player/npc p see this kind of trap, either by their memory (they known there is the trap) or by t...
Definition: trap.cpp:223
bool is_benign() const
If true, this is not really a trap and there won't be any safety queries before stepping onto it (e....
Definition: trap.h:159

References bp_arm_l, bp_arm_r, bp_eyes, bp_foot_l, bp_foot_r, bp_hand_l, bp_hand_r, bp_head, bp_leg_l, bp_leg_r, bp_mouth, bp_torso, trap::can_see(), Character::dex_cur, DT_CUT, map::field_at(), Character::get_armor_bash(), map::has_flag(), map::has_zlevels(), Character::in_vehicle, trap::is_benign(), Character::is_blind(), character_funcs::is_bp_immune_to(), Creature::is_dangerous_field(), trap::loadid, m, trap::name(), map::name(), optional_vpart_position::part_with_feature(), Character::pos(), map::tr_at(), tr_ledge, u, and map::veh_at().

Referenced by is_dangerous_tile(), prompt_dangerous_tile(), and walk_move().

◆ get_fishable_locations()

std::unordered_set< tripoint > game::get_fishable_locations ( int  distance,
const tripoint fish_pos 
)

Get the contiguous fishable locations starting at fish_pos, out to the specificed distance.

Parameters
distanceDistance around the fish_pos to examine for contiguous fishable locations.
fish_posThe location being fished.
Returns
A set of locations representing the valid contiguous fishable locations.

Definition at line 3602 of file game.cpp.

3603{
3604 // We're going to get the contiguous fishable terrain starting at
3605 // the provided fishing location (e.g. where a line was cast or a fish
3606 // trap was set), and then check whether or not fishable monsters are
3607 // actually in those locations. This will help us ensure that we're
3608 // getting our fish from the location that we're ACTUALLY fishing,
3609 // rather than just somewhere in the vicinity.
3610
3611 std::unordered_set<tripoint> visited;
3612
3613 const tripoint fishing_boundary_min( fish_pos + point( -distance, -distance ) );
3614 const tripoint fishing_boundary_max( fish_pos + point( distance, distance ) );
3615
3616 const inclusive_cuboid<tripoint> fishing_boundaries(
3617 fishing_boundary_min, fishing_boundary_max );
3618
3619 const auto get_fishable_terrain = [&]( tripoint starting_point,
3620 std::unordered_set<tripoint> &fishable_terrain ) {
3621 std::queue<tripoint> to_check;
3622 to_check.push( starting_point );
3623 while( !to_check.empty() ) {
3624 const tripoint current_point = to_check.front();
3625 to_check.pop();
3626
3627 // We've been here before, so bail.
3628 if( visited.find( current_point ) != visited.end() ) {
3629 continue;
3630 }
3631
3632 // This point is out of bounds, so bail.
3633 if( !fishing_boundaries.contains( current_point ) ) {
3634 continue;
3635 }
3636
3637 // Mark this point as visited.
3638 visited.emplace( current_point );
3639
3640 if( m.has_flag( "FISHABLE", current_point ) ) {
3641 fishable_terrain.emplace( current_point );
3642 to_check.push( current_point + point_south );
3643 to_check.push( current_point + point_north );
3644 to_check.push( current_point + point_east );
3645 to_check.push( current_point + point_west );
3646 }
3647 }
3648 return;
3649 };
3650
3651 // Starting at the provided location, get our fishable terrain
3652 // and populate a set with those locations which we'll then use
3653 // to determine if any fishable monsters are in those locations.
3654 std::unordered_set<tripoint> fishable_points;
3655 get_fishable_terrain( fish_pos, fishable_points );
3656
3657 return fishable_points;
3658}
static constexpr point point_west
Definition: point.h:268
static constexpr point point_south
Definition: point.h:266
static constexpr point point_north
Definition: point.h:262
static constexpr point point_east
Definition: point.h:264

References inclusive_cuboid< Tripoint, >::contains(), map::has_flag(), m, point_east, point_north, point_south, and point_west.

◆ get_fishable_monsters()

std::vector< monster * > game::get_fishable_monsters ( std::unordered_set< tripoint > &  fishable_locations)

Get the fishable monsters within the provided fishable locations.

Parameters
fishable_locationsA set of locations which are valid fishable terrain. Any fishable monsters are filtered by this collection to determine those which can actually be caught.
Returns
Fishable monsters within the specified fishable terrain.

Definition at line 3660 of file game.cpp.

3662{
3663 std::vector<monster *> unique_fish;
3664 for( monster &critter : all_monsters() ) {
3665 // If it is fishable...
3666 if( critter.has_flag( MF_FISHABLE ) ) {
3667 const tripoint critter_pos = critter.pos();
3668 // ...and it is in a fishable location.
3669 if( fishable_locations.find( critter_pos ) != fishable_locations.end() ) {
3670 unique_fish.push_back( &critter );
3671 }
3672 }
3673 }
3674
3675 return unique_fish;
3676}
@ MF_FISHABLE
Definition: mtype.h:142

References all_monsters(), and MF_FISHABLE.

◆ get_follower_list()

std::set< character_id > game::get_follower_list ( )

Get set of followers.

Definition at line 1976 of file game.cpp.

1977{
1978 return follower_ids;
1979}

References follower_ids.

◆ get_kill_tracker()

const kill_tracker & game::get_kill_tracker ( ) const

Definition at line 886 of file game.cpp.

887{
888 return *kill_tracker_ptr;
889}

References kill_tracker_ptr.

Referenced by cleanup_at_end(), death_screen(), handle_action(), and win().

◆ get_levx()

int game::get_levx ( ) const

The top left corner of the reality bubble (in submaps coordinates).

This is the same as map::abs_sub of the m map.

Definition at line 11886 of file game.cpp.

11887{
11888 return m.get_abs_sub().x;
11889}

References map::get_abs_sub(), m, and tripoint::x.

Referenced by create_starting_npcs(), load_npcs(), look_around(), save_cyborg(), spawn_hallucination(), vertical_move(), and vertical_shift().

◆ get_levy()

int game::get_levy ( ) const

Definition at line 11891 of file game.cpp.

11892{
11893 return m.get_abs_sub().y;
11894}

References map::get_abs_sub(), m, and tripoint::y.

Referenced by create_starting_npcs(), load_npcs(), look_around(), save_cyborg(), spawn_hallucination(), vertical_move(), and vertical_shift().

◆ get_levz()

◆ get_moves_since_last_save()

int game::get_moves_since_last_save ( ) const

Definition at line 7103 of file game.cpp.

7104{
7105 return moves_since_last_save;
7106}

References moves_since_last_save.

◆ get_npcs_if()

std::vector< npc * > game::get_npcs_if ( const std::function< bool(const npc &)> &  pred)

Definition at line 11933 of file game.cpp.

11934{
11935 std::vector<npc *> result;
11936 for( npc &guy : all_npcs() ) {
11937 if( pred( guy ) ) {
11938 result.push_back( &guy );
11939 }
11940 }
11941 return result;
11942}

References all_npcs().

Referenced by allies(), chat(), and validate_npc_followers().

◆ get_player_base_save_path()

std::string game::get_player_base_save_path ( ) const

Base path for saving player data.

Just add a suffix (unique for the thing you want to save) and use the resulting path. Example: save_ui_data(get_player_base_save_path()+".ui")

Definition at line 12021 of file game.cpp.

12022{
12023 return get_world_base_save_path() + "/" + base64_encode( get_avatar().get_save_id() );
12024}
std::string base64_encode(const std::string &str)
std::string get_world_base_save_path() const
Base path for saving world data.
Definition: game.cpp:12026
friend avatar & get_avatar()
Definition: avatar.cpp:104

References base64_encode(), get_avatar, and get_world_base_save_path().

Referenced by save_player_data().

◆ get_player_input()

input_context game::get_player_input ( std::string &  action)
private

Definition at line 245 of file handle_action.cpp.

246{
247 input_context ctxt;
248 if( uquit == QUIT_WATCH ) {
249 ctxt = input_context( "DEFAULTMODE" );
250 ctxt.set_iso( true );
251 // The list of allowed actions in death-cam mode in game::handle_action
252 // *INDENT-OFF*
253 for( const action_id id : {
266 } ) {
267 ctxt.register_action( action_ident( id ) );
268 }
269 // *INDENT-ON*
270 ctxt.register_action( "QUIT", to_translation( "Accept your fate" ) );
271 } else {
273 }
274
276
277 user_turn current_turn;
278
279
280 // Checking early if we will need to handle animations
281 // If we do not need to handle animations that will not change as long as the user has not selected an action
282 // and we can handle it like we are not animating.
283 weather_printable wPrint;
284 bool animate_weather = false;
285 bool animate_sct = false;
286 bool do_animations = [&]() {
287 if( get_option<bool>( "ANIMATIONS" ) ) {
288 const bool weather_has_anim = init_weather_anim( get_weather().weather_id, wPrint );
289
290 animate_weather = weather_has_anim && get_option<bool>( "ANIMATION_RAIN" );
291 animate_sct = !SCT.vSCT.empty() && uquit != QUIT_WATCH && get_option<bool>( "ANIMATION_SCT" );
292
293#if defined(TILES)
294 // Always animate, minimap and terrain may have animations to run
295 return true;
296#else
297 // Otherwise we need to see if we actually should animate.
298 // Minimap and Terrain never animate in !TILES
299 return animate_weather || animate_sct || uquit == QUIT_WATCH;
300#endif
301 }
302 return false;
303 }
304 ();
305
306 if( do_animations ) {
307 ctxt.set_timeout( 125 );
308
310 make_shared_fast<game::draw_callback_t>( [&]() {
311 if( animate_weather ) {
312 draw_weather( wPrint );
313 }
314 if( animate_sct ) {
315 draw_sct();
316 }
317 } );
318 add_draw_callback( animation_cb );
319 invalidate_main_ui_adaptor(); // We want to redraw at least once.
320
321 do {
322 if( animate_weather ) {
324 generate_weather_anim_frame( get_weather().weather_id, wPrint );
325 }
326 // don't bother calculating SCT if we won't show it
327 if( animate_sct ) {
329
331
332 //Check for creatures on all drawing positions and offset if necessary
333 for( auto iter = SCT.vSCT.rbegin(); iter != SCT.vSCT.rend(); ++iter ) {
334 const direction oCurDir = iter->getDirecton();
335 const int width = utf8_width( iter->getText() );
336 for( int i = 0; i < width; ++i ) {
337 tripoint tmp( iter->getPosX() + i, iter->getPosY(), get_levz() );
338 const Creature *critter = critter_at( tmp, true );
339
340 if( critter != nullptr && u.sees( *critter ) ) {
341 i = -1;
342 int iPos = iter->getStep() + iter->getStepOffset();
343 for( auto iter2 = iter; iter2 != SCT.vSCT.rend(); ++iter2 ) {
344 if( iter2->getDirecton() == oCurDir &&
345 iter2->getStep() + iter2->getStepOffset() <= iPos ) {
346 if( iter2->getType() == "hp" ) {
347 iter2->advanceStepOffset();
348 }
349
350 iter2->advanceStepOffset();
351 iPos = iter2->getStep() + iter2->getStepOffset();
352 }
353 }
354 }
355 }
356 }
357
358 // Stop animation when done
359 animate_sct = !SCT.vSCT.empty();
360 }
361 // We don't cache these checks as their result may change after 1st redraw
363 // TODO: we redraw *everything* just to animate a couple blinking dots
364 // on the minimap or a few tiles.
365 // This is far from ideal, and can probably be done much cheaper
366 // (update only part of the screen? draw static parts into a texture?)
368 }
369
370 std::unique_ptr<static_popup> deathcam_msg_popup;
371 if( uquit == QUIT_WATCH ) {
372 deathcam_msg_popup = std::make_unique<static_popup>();
373 deathcam_msg_popup
374 ->wait_message( c_red, _( "Press %s to accept your fate…" ), ctxt.get_desc( "QUIT" ) )
375 .on_top( true );
376 }
377
379 } while( handle_mouseview( ctxt, action ) && uquit != QUIT_WATCH
380 && ( action != "TIMEOUT" || !current_turn.has_timeout_elapsed() ) );
381 ctxt.reset_timeout();
382 } else {
385 SCT.vSCT.clear();
386
387 ctxt.set_timeout( 125 );
388 while( handle_mouseview( ctxt, action ) ) {
389 if( action == "TIMEOUT" && current_turn.has_timeout_elapsed() ) {
390 break;
391 }
392 }
393 ctxt.reset_timeout();
394 }
395
396 return ctxt;
397}
std::string action_ident(action_id act)
Lookup a unique string identifier for a given action ID.
Definition: action.cpp:68
action_id
Enumerates all discrete actions that can be performed by player.
Definition: action.h:18
@ ACTION_CENTER
Center the viewport on character.
Definition: action.h:73
@ ACTION_SHIFT_SW
Move viewport south-west.
Definition: action.h:85
@ ACTION_SHIFT_NW
Move viewport north-west.
Definition: action.h:89
@ ACTION_KEYBINDINGS
Display keybindings list.
Definition: action.h:255
@ ACTION_SHIFT_E
Move viewport east.
Definition: action.h:79
@ ACTION_TOGGLE_MAP_MEMORY
Toggle memorized tiles being shown.
Definition: action.h:71
@ ACTION_SHIFT_S
Move viewport south.
Definition: action.h:83
@ ACTION_SHIFT_SE
Move viewport south-east.
Definition: action.h:81
@ ACTION_LOOK
Toggle look mode.
Definition: action.h:115
@ ACTION_SHIFT_NE
Move viewport north-east.
Definition: action.h:77
@ ACTION_SHIFT_W
Move viewport west.
Definition: action.h:87
@ ACTION_SHIFT_N
Move viewport north.
Definition: action.h:75
bool terrain_requires_animation()
Definition: animation.cpp:1204
bool minimap_requires_animation()
Definition: animation.cpp:1195
void draw_sct()
Definition: animation.cpp:865
void draw_weather(const weather_printable &wPrint)
Definition: animation.cpp:824
void add_draw_callback(shared_ptr_fast< draw_callback_t > cb)
Definition: game.cpp:3015
bool handle_mouseview(input_context &ctxt, std::string &action)
Definition: game.cpp:2007
void set_timeout(int val)
Sets input polling timeout as appropriate for the current interface system.
Definition: input.cpp:1452
std::string get_desc(const std::string &action_descriptor, unsigned int max_limit=0, const input_event_filter &evt_filter=allow_all_keys) const
Get a description text for the key/other input method associated with the given action.
Definition: input.cpp:750
void register_action(const std::string &action_descriptor)
Register an action with this input context.
Definition: input.cpp:672
void set_iso(bool mode=true)
Definition: input.cpp:1423
void reset_timeout()
Definition: input.cpp:1457
std::vector< cSCT > vSCT
Definition: output.h:916
void advanceAllSteps()
Definition: output.cpp:1924
bool has_timeout_elapsed()
input_context get_default_mode_input_context()
Definition: game.cpp:2107
static bool init_weather_anim(const weather_type_id &wtype, weather_printable &wPrint)
static void generate_weather_anim_frame(const weather_type_id &wtype, weather_printable &wPrint)
direction
Definition: line.h:39
scrollingcombattext SCT
Definition: output.cpp:65
Weather drawing tracking.
Definition: weather.h:59
translation to_translation(const std::string &raw)
Shorthands for translation::to_translation.

References _, action, ACTION_CENTER, action_ident(), ACTION_KEYBINDINGS, ACTION_LOOK, ACTION_SHIFT_E, ACTION_SHIFT_N, ACTION_SHIFT_NE, ACTION_SHIFT_NW, ACTION_SHIFT_S, ACTION_SHIFT_SE, ACTION_SHIFT_SW, ACTION_SHIFT_W, ACTION_TOGGLE_MAP_MEMORY, add_draw_callback(), scrollingcombattext::advanceAllSteps(), c_red, critter_at(), draw_sct(), draw_weather(), generate_weather_anim_frame(), get_default_mode_input_context(), input_context::get_desc(), get_levz(), get_weather, handle_mouseview(), user_turn::has_timeout_elapsed(), init_weather_anim(), invalidate_main_ui_adaptor(), m, minimap_requires_animation(), Character::posz(), QUIT_WATCH, ui_manager::redraw_invalidated(), input_context::register_action(), input_context::reset_timeout(), SCT, Character::sees(), input_context::set_iso(), input_context::set_timeout(), terrain_requires_animation(), to_translation(), u, map::update_visibility_cache(), uquit, utf8_width(), and scrollingcombattext::vSCT.

Referenced by handle_action().

◆ get_seed()

unsigned int game::get_seed ( ) const

Definition at line 1788 of file game.cpp.

1789{
1790 return seed;
1791}

References seed.

◆ get_user_action_counter()

int game::get_user_action_counter ( ) const

Definition at line 7108 of file game.cpp.

7109{
7110 return user_action_counter;
7111}

References user_action_counter.

◆ get_veh_dir_indicator_location()

std::optional< tripoint > game::get_veh_dir_indicator_location ( bool  next) const

Returns the location where the indicator should go relative to the reality bubble, or nothing to indicate no indicator should be drawn.

Based on the vehicle the player is driving, if any.

Parameters
nextIf true, bases it on the vehicle the vehicle will turn to next turn, instead of the one it is currently facing.

Definition at line 3270 of file game.cpp.

3271{
3272 if( !get_option<bool>( "VEHICLE_DIR_INDICATOR" ) ) {
3273 return std::nullopt;
3274 }
3275 const optional_vpart_position vp = m.veh_at( u.pos() );
3276 if( !vp ) {
3277 return std::nullopt;
3278 }
3279 vehicle *const veh = &vp->vehicle();
3280 rl_vec2d face = next ? veh->dir_vec() : veh->face_vec();
3281 float r = 10.0;
3282 return tripoint( static_cast<int>( r * face.x ), static_cast<int>( r * face.y ), u.pos().z );
3283}
rl_vec2d dir_vec() const

References vehicle::dir_vec(), vehicle::face_vec(), m, Character::pos(), u, map::veh_at(), rl_vec2d::x, rl_vec2d::y, and tripoint::z.

Referenced by draw_veh_dir_indicator().

◆ get_world_base_save_path()

std::string game::get_world_base_save_path ( ) const

Base path for saving world data.

This yields a path to a folder.

Definition at line 12026 of file game.cpp.

12027{
12028 if( world_generator->active_world == nullptr ) {
12029 return PATH_INFO::savedir();
12030 }
12031 return world_generator->active_world->folder_path();
12032}
std::string savedir()
Definition: path_info.cpp:246

References PATH_INFO::savedir(), and world_generator.

Referenced by get_player_base_save_path(), load(), load_master(), move_save_to_graveyard(), save(), save_artifacts(), save_factions_missions_npcs(), and setup().

◆ get_zoom()

int game::get_zoom ( ) const

Definition at line 7094 of file game.cpp.

7095{
7096#if defined(TILES)
7097 return tileset_zoom;
7098#else
7099 return DEFAULT_TILESET_ZOOM;
7100#endif
7101}

References DEFAULT_TILESET_ZOOM, and tileset_zoom.

Referenced by look_around().

◆ grabbed_furn_move()

bool game::grabbed_furn_move ( const tripoint dp)
private
Strength determines ability to drag furniture

Definition at line 9520 of file game.cpp.

9521{
9522 // Furniture: pull, push, or standing still and nudging object around.
9523 // Can push furniture out of reach.
9524 tripoint fpos = u.pos() + u.grab_point;
9525 // supposed position of grabbed furniture
9526 if( !m.has_furn( fpos ) ) {
9527 // Where did it go? We're grabbing thin air so reset.
9528 add_msg( m_info, _( "No furniture at grabbed point." ) );
9529 u.grab( OBJECT_NONE );
9530 return false;
9531 }
9532
9533 const bool pushing_furniture = dp == u.grab_point;
9534 const bool pulling_furniture = dp == -u.grab_point;
9535 const bool shifting_furniture = !pushing_furniture && !pulling_furniture;
9536
9537 tripoint fdest = fpos + dp; // intended destination of furniture.
9538 // Check floor: floorless tiles don't need to be flat and have no traps
9539 const bool has_floor = m.has_floor( fdest );
9540 // Unfortunately, game::is_empty fails for tiles we're standing on,
9541 // which will forbid pulling, so:
9542 const bool canmove = (
9543 m.passable( fdest ) &&
9544 critter_at<npc>( fdest ) == nullptr &&
9545 critter_at<monster>( fdest ) == nullptr &&
9546 ( !pulling_furniture || is_empty( u.pos() + dp ) ) &&
9547 ( !has_floor || m.has_flag( "FLAT", fdest ) ) &&
9548 !m.has_furn( fdest ) &&
9549 !m.veh_at( fdest ) &&
9550 ( !has_floor || m.tr_at( fdest ).is_null() )
9551 );
9552
9553 const furn_t furntype = m.furn( fpos ).obj();
9554 const int src_items = m.i_at( fpos ).size();
9555 const int dst_items = m.i_at( fdest ).size();
9556
9557 const bool only_liquid_items = std::all_of( m.i_at( fdest ).begin(), m.i_at( fdest ).end(),
9558 [&]( item & liquid_item ) {
9559 return liquid_item.made_of( LIQUID );
9560 } );
9561
9562 const bool dst_item_ok = !m.has_flag( "NOITEM", fdest ) &&
9563 !m.has_flag( "SWIMMABLE", fdest ) &&
9564 !m.has_flag( "DESTROY_ITEM", fdest );
9565
9566 const bool src_item_ok = m.furn( fpos ).obj().has_flag( "CONTAINER" ) ||
9567 m.furn( fpos ).obj().has_flag( "FIRE_CONTAINER" ) ||
9568 m.furn( fpos ).obj().has_flag( "SEALED" );
9569
9570 const int fire_intensity = m.get_field_intensity( fpos, fd_fire );
9571 time_duration fire_age = m.get_field_age( fpos, fd_fire );
9572
9573 int str_req = furntype.move_str_req;
9574 // Factor in weight of items contained in the furniture.
9575 units::mass furniture_contents_weight = 0_gram;
9576 for( auto &contained_item : m.i_at( fpos ) ) {
9577 furniture_contents_weight += contained_item.weight();
9578 }
9579 str_req += furniture_contents_weight / 4_kilogram;
9580 if( !canmove ) {
9581 // TODO: What is something?
9582 add_msg( _( "The %s collides with something." ), furntype.name() );
9583 u.moves -= 50;
9584 return true;
9585 ///\EFFECT_STR determines ability to drag furniture
9586 } else if( str_req > u.get_str() &&
9587 one_in( std::max( 20 - str_req - u.get_str(), 2 ) ) ) {
9588 add_msg( m_bad, _( "You strain yourself trying to move the heavy %s!" ),
9589 furntype.name() );
9590 u.moves -= 100;
9591 u.mod_pain( 1 ); // Hurt ourselves.
9592 return true; // furniture and or obstacle wins.
9593 } else if( !src_item_ok && !only_liquid_items && dst_items > 0 ) {
9594 add_msg( _( "There's stuff in the way." ) );
9595 u.moves -= 50;
9596 return true;
9597 }
9598
9599 u.moves -= str_req * 10;
9600 // Additional penalty if we can't comfortably move it.
9601 if( str_req > u.get_str() ) {
9602 int move_penalty = std::pow( str_req, 2.0 ) + 100.0;
9603 if( move_penalty <= 1000 ) {
9604 if( u.get_str() >= str_req - 3 ) {
9605 u.moves -= std::max( 3000, move_penalty * 10 );
9606 add_msg( m_bad, _( "The %s is really heavy!" ), furntype.name() );
9607 if( one_in( 3 ) ) {
9608 add_msg( m_bad, _( "You fail to move the %s." ), furntype.name() );
9609 return true;
9610 }
9611 } else {
9612 u.moves -= 100;
9613 add_msg( m_bad, _( "The %s is too heavy for you to budge." ), furntype.name() );
9614 return true;
9615 }
9616 }
9617 u.moves -= move_penalty;
9618 if( move_penalty > 500 ) {
9619 add_msg( _( "Moving the heavy %s is taking a lot of time!" ),
9620 furntype.name() );
9621 } else if( move_penalty > 200 ) {
9622 if( one_in( 3 ) ) { // Nag only occasionally.
9623 add_msg( _( "It takes some time to move the heavy %s." ),
9624 furntype.name() );
9625 }
9626 }
9627 }
9629 _( "a scraping noise." ), true, "misc", "scraping" );
9630
9632 ( tripoint_abs_ms( m.getabs( fpos ) ) );
9633
9634 // Actually move the furniture.
9635 m.furn_set( fdest, m.furn( fpos ), atd ? atd->clone() : nullptr );
9636 m.furn_set( fpos, f_null );
9637
9638 if( fire_intensity == 1 && !pulling_furniture ) {
9639 m.remove_field( fpos, fd_fire );
9640 m.set_field_intensity( fdest, fd_fire, fire_intensity );
9641 m.set_field_age( fdest, fd_fire, fire_age );
9642 }
9643
9644 // Is there is only liquids on the ground, remove them after moving furniture.
9645 if( dst_items > 0 && only_liquid_items ) {
9646 m.i_clear( fdest );
9647 }
9648
9649 if( src_items > 0 ) { // Move the stuff inside.
9650 if( dst_item_ok && src_item_ok ) {
9651 // Assume contents of both cells are legal, so we can just swap contents.
9652 std::list<item> temp;
9653 std::move( m.i_at( fpos ).begin(), m.i_at( fpos ).end(),
9654 std::back_inserter( temp ) );
9655 m.i_clear( fpos );
9656 for( auto item_iter = m.i_at( fdest ).begin();
9657 item_iter != m.i_at( fdest ).end(); ++item_iter ) {
9658 m.i_at( fpos ).insert( *item_iter );
9659 }
9660 m.i_clear( fdest );
9661 for( auto &cur_item : temp ) {
9662 m.i_at( fdest ).insert( cur_item );
9663 }
9664 } else {
9665 add_msg( _( "Stuff spills from the %s!" ), furntype.name() );
9666 }
9667 }
9668
9669 if( shifting_furniture ) {
9670 // We didn't move
9671 tripoint d_sum = u.grab_point + dp;
9672 if( std::abs( d_sum.x ) < 2 && std::abs( d_sum.y ) < 2 ) {
9673 u.grab_point = d_sum; // furniture moved relative to us
9674 } else { // we pushed furniture out of reach
9675 add_msg( _( "You let go of the %s." ), furntype.name() );
9676 u.grab( OBJECT_NONE );
9677 }
9678 return true; // We moved furniture but stayed still.
9679 }
9680
9681 if( pushing_furniture && m.impassable( fpos ) ) {
9682 // Not sure how that chair got into a wall, but don't let player follow.
9683 add_msg( _( "You let go of the %1$s as it slides past %2$s." ),
9684 furntype.name(), m.tername( fdest ) );
9685 u.grab( OBJECT_NONE );
9686 return true;
9687 }
9688
9689 return false;
9690}
virtual int get_str() const
Getters for stats exclusive to characters.
Definition: character.cpp:4078
virtual active_tile_data * clone() const =0
void grab(object_type grab_type, const tripoint &grab_point=tripoint_zero)
Definition: avatar.cpp:664
bool is_empty(const tripoint &p)
Returns true if there is no player, NPC, or monster on the tile and move_cost > 0.
Definition: game.cpp:4839
void insert(const item &newitem) override
Definition: map.cpp:158
void remove_field(const tripoint &p, const field_type_id &field_to_remove)
Remove field entry at xy, ignored if the field entry is not present.
Definition: map.cpp:5564
time_duration set_field_age(const tripoint &p, const field_type_id &type, const time_duration &age, bool isoffset=false)
Set age of field entry at point.
Definition: map.cpp:5438
time_duration get_field_age(const tripoint &p, const field_type_id &type) const
Get the age of a field entry (field_entry::age), if there is no field of that type,...
Definition: map.cpp:5472
int get_field_intensity(const tripoint &p, const field_type_id &type) const
Get the intensity of a field entry (field_entry::intensity), if there is no field of that type,...
Definition: map.cpp:5478
int set_field_intensity(const tripoint &p, const field_type_id &type, int new_intensity, bool isoffset=false)
Set intensity of field entry at point, creating if not present, removing if intensity becomes 0.
Definition: map.cpp:5451
std::string tername(const tripoint &p) const
Definition: map.cpp:1773
void i_clear(const tripoint &p)
Definition: map.cpp:4226
void furn_set(const tripoint &p, const furn_id &new_furniture, cata::poly_serialized< active_tile_data > new_active=nullptr)
Sets the furniture at given position.
Definition: map.cpp:1424
bool has_floor(const tripoint &p) const
Definition: map.cpp:2071
tripoint grab_point
Definition: player.h:235
@ OBJECT_NONE
Definition: enums.h:187
field_type_id fd_fire
Definition: field_type.cpp:345
furn_id f_null
Definition: mapdata.cpp:1097
template active_tile_data * furn_at< active_tile_data >(const tripoint_abs_ms &)
bool move(avatar &you, map &m, const tripoint &d)
void sound(const tripoint &p, int vol, sound_t category, const std::string &description, bool ambient=false, const std::string &id="", const std::string &variant="default")
Sound at (p) of intensity (vol)
Definition: sounds.cpp:177
int move_str_req
Definition: mapdata.h:515
bool has_flag(const std::string &flag) const
Definition: mapdata.h:419

References _, add_msg(), item_stack::begin(), active_tile_data::clone(), item_stack::end(), f_null, fd_fire, map::furn(), active_tiles::furn_at< active_tile_data >(), map::furn_set(), map::get_field_age(), map::get_field_intensity(), Character::get_str(), map::getabs(), avatar::grab(), player::grab_point, map_data_common_t::has_flag(), map::has_flag(), map::has_floor(), map::has_furn(), map::i_at(), map::i_clear(), map::impassable(), map_stack::insert(), is_empty(), trap::is_null(), m, m_bad, m_info, Character::mod_pain(), avatar_action::move(), furn_t::move_str_req, sounds::movement, Creature::moves, map_data_common_t::name(), int_id< T >::obj(), OBJECT_NONE, one_in(), map::passable(), Character::pos(), map::remove_field(), map::set_field_age(), map::set_field_intensity(), item_stack::size(), sounds::sound(), map::tername(), map::tr_at(), u, map::veh_at(), tripoint::x, and tripoint::y.

Referenced by grabbed_move().

◆ grabbed_move()

bool game::grabbed_move ( const tripoint dp)
private

Check for dangerous stuff at dest_loc, return false if the player decides not to step there.

Definition at line 9692 of file game.cpp.

9693{
9694 if( u.get_grab_type() == OBJECT_NONE ) {
9695 return false;
9696 }
9697
9698 if( dp.z != 0 ) {
9699 // No dragging stuff up/down stairs yet!
9700 return false;
9701 }
9702
9703 // vehicle: pulling, pushing, or moving around the grabbed object.
9704 if( u.get_grab_type() == OBJECT_VEHICLE ) {
9705 return grabbed_veh_move( dp );
9706 }
9707
9708 if( u.get_grab_type() == OBJECT_FURNITURE ) {
9709 return grabbed_furn_move( dp );
9710 }
9711
9712 add_msg( m_info, _( "Nothing at grabbed point %d,%d,%d or bad grabbed object type." ),
9714 u.grab( OBJECT_NONE );
9715 return false;
9716}
object_type get_grab_type() const
Definition: avatar.cpp:672
bool grabbed_furn_move(const tripoint &dp)
Definition: game.cpp:9520
bool grabbed_veh_move(const tripoint &dp)
Definition: grab.cpp:93
@ OBJECT_FURNITURE
Definition: enums.h:197
@ OBJECT_VEHICLE
Definition: enums.h:193

References _, add_msg(), avatar::get_grab_type(), avatar::grab(), player::grab_point, grabbed_furn_move(), grabbed_veh_move(), m_info, OBJECT_FURNITURE, OBJECT_NONE, OBJECT_VEHICLE, u, tripoint::x, tripoint::y, and tripoint::z.

Referenced by walk_move().

◆ grabbed_veh_move()

bool game::grabbed_veh_move ( const tripoint dp)
private
Strength determines ability to drag vehicles Strength increases speed of dragging vehicles Strength decreases stamina cost of dragging vehicles

Definition at line 93 of file grab.cpp.

94{
95 const optional_vpart_position grabbed_vehicle_vp = m.veh_at( u.pos() + u.grab_point );
96 if( !grabbed_vehicle_vp ) {
97 add_msg( m_info, _( "No vehicle at grabbed point." ) );
99 return false;
100 }
101 vehicle *grabbed_vehicle = &grabbed_vehicle_vp->vehicle();
102 if( !grabbed_vehicle ||
103 !grabbed_vehicle->handle_potential_theft( u ) ) {
104 return false;
105 }
106 const int grabbed_part = grabbed_vehicle_vp->part_index();
107 for( int part_index = 0; part_index < grabbed_vehicle->part_count(); ++part_index ) {
108 monster *mon = grabbed_vehicle->get_pet( part_index );
109 if( mon != nullptr && mon->has_effect( effect_harnessed ) ) {
110 add_msg( m_info, _( "You cannot move this vehicle whilst your %s is harnessed!" ),
111 mon->get_name() );
112 u.grab( OBJECT_NONE );
113 return false;
114 }
115 }
116 const vehicle *veh_under_player = veh_pointer_or_null( m.veh_at( u.pos() ) );
117 if( grabbed_vehicle == veh_under_player ) {
118 u.grab_point = -dp;
119 return false;
120 }
121
122 tripoint dp_veh = -u.grab_point;
123 const tripoint prev_grab = u.grab_point;
124 tripoint next_grab = u.grab_point;
125
126 bool zigzag = false;
127
128 if( dp == prev_grab ) {
129 // We are pushing in the direction of vehicle
130 dp_veh = dp;
131 } else if( std::abs( dp.x + dp_veh.x ) != 2 && std::abs( dp.y + dp_veh.y ) != 2 ) {
132 // Not actually moving the vehicle, don't do the checks
133 u.grab_point = -( dp + dp_veh );
134 return false;
135 } else if( ( dp.x == prev_grab.x || dp.y == prev_grab.y ) &&
136 next_grab.x != 0 && next_grab.y != 0 ) {
137 // Zig-zag (or semi-zig-zag) pull: player is diagonal to vehicle
138 // and moves away from it, but not directly away
139 dp_veh.x = dp.x == -dp_veh.x ? 0 : dp_veh.x;
140 dp_veh.y = dp.y == -dp_veh.y ? 0 : dp_veh.y;
141
142 next_grab = -dp_veh;
143 zigzag = true;
144 } else {
145 // We are pulling the vehicle
146 next_grab = -dp;
147 }
148
149 // Make sure the mass and pivot point are correct
150 grabbed_vehicle->invalidate_mass();
151
152 //vehicle movement: strength check. very strong humans can move about 2,000 kg in a wheelbarrow.
153 // int str_req = grabbed_vehicle->total_mass() / 100_kilogram; //strength required to move vehicle.
154 // for smaller vehicles, offroad_str_req_cap sanity-checks our results.
155 int str_req = std::min( get_vehicle_str_requirement( grabbed_vehicle ),
156 offroad_str_req_cap( grabbed_vehicle ) );
157 const int str = u.get_str();
158 add_msg( m_debug, "str_req: %d", str_req );
159
160 //final strength check and outcomes
161 ///\EFFECT_STR determines ability to drag vehicles
162 if( str_req <= str ) {
163 if( !grabbed_vehicle->valid_wheel_config() ) {
164 make_scraping_noise( grabbed_vehicle->global_pos3(), str_req * 2 );
165 }
166
167 //calculate exertion factor and movement penalty
168 ///\EFFECT_STR increases speed of dragging vehicles
169 u.moves -= 400 * str_req / std::max( 1, str );
170 ///\EFFECT_STR decreases stamina cost of dragging vehicles
171 u.mod_stamina( -200 * str_req / std::max( 1, str ) );
172 const int ex = dice( 1, 6 ) - 1 + str_req;
173 if( ex > str + 1 ) {
174 // Pain and movement penalty if exertion exceeds character strength
175 add_msg( m_bad, _( "You strain yourself to move the %s!" ), grabbed_vehicle->name );
176 u.moves -= 200;
177 u.mod_pain( 1 );
178 } else if( ex >= str ) {
179 // Movement is slow if exertion nearly equals character strength
180 add_msg( _( "It takes some time to move the %s." ), grabbed_vehicle->name );
181 u.moves -= 200;
182 }
183 } else {
184 u.moves -= 100;
185 add_msg( m_bad, _( "You lack the strength to move the %s" ), grabbed_vehicle->name );
186 return true;
187 }
188
189 std::string blocker_name = _( "errors in movement code" );
190 const auto get_move_dir = [&]( const tripoint & dir, const tripoint & from ) {
191 tileray mdir;
192
193 mdir.init( dir.xy() );
194 grabbed_vehicle->turn( mdir.dir() - grabbed_vehicle->face.dir() );
195 grabbed_vehicle->face = grabbed_vehicle->turn_dir;
196 grabbed_vehicle->precalc_mounts( 1, mdir.dir(), grabbed_vehicle->pivot_point() );
197
198 // Grabbed part has to stay at distance 1 to the player
199 // and in roughly the same direction.
200 const tripoint new_part_pos = grabbed_vehicle->global_pos3() +
201 grabbed_vehicle->part( grabbed_part ).precalc[ 1 ];
202 const tripoint expected_pos = u.pos() + dp + from;
203 const tripoint actual_dir = expected_pos - new_part_pos;
204
205 grabbed_vehicle->adjust_zlevel( 1, dp );
206
207 // Set player location to illegal value so it can't collide with vehicle.
208 const tripoint player_prev = u.pos();
210 std::vector<veh_collision> colls;
211 const bool failed = grabbed_vehicle->collision( colls, actual_dir, true );
212 u.setpos( player_prev );
213 if( !colls.empty() ) {
214 blocker_name = colls.front().target_name;
215 }
216 return failed ? tripoint_zero : actual_dir;
217 };
218
219 // First try the move as intended
220 // But if that fails and the move is a zig-zag, try to recover:
221 // Try to place the vehicle in the position player just left rather than "flattening" the zig-zag
222 tripoint final_dp_veh = get_move_dir( dp_veh, next_grab );
223 if( final_dp_veh == tripoint_zero && zigzag ) {
224 final_dp_veh = get_move_dir( -prev_grab, -dp );
225 next_grab = -dp;
226 }
227
228 if( final_dp_veh == tripoint_zero ) {
229 add_msg( _( "The %s collides with %s." ), grabbed_vehicle->name, blocker_name );
230 u.grab_point = prev_grab;
231 return true;
232 }
233
234 u.grab_point = next_grab;
235
236 m.displace_vehicle( *grabbed_vehicle, final_dp_veh );
237
238 if( grabbed_vehicle ) {
239 grabbed_vehicle->shift_zlevel();
240 grabbed_vehicle->check_falling_or_floating();
241 } else {
242 debugmsg( "Grabbed vehicle disappeared" );
243 return false;
244 }
245
246 for( int p : grabbed_vehicle->wheelcache ) {
247 if( one_in( 2 ) ) {
248 tripoint wheel_p = grabbed_vehicle->global_part_pos3( grabbed_part );
249 grabbed_vehicle->handle_trap( wheel_p, p );
250 }
251 }
252
253 return false;
254
255}
void mod_stamina(int mod)
Definition: character.cpp:7095
bool displace_vehicle(vehicle &veh, const tripoint &dp)
Definition: map.cpp:1183
void init(point ad)
Definition: tileray.cpp:27
units::angle dir() const
Definition: tileray.cpp:74
void turn(units::angle deg)
void adjust_zlevel(int idir=0, const tripoint &offset=tripoint_zero)
tripoint global_pos3() const
Definition: vehicle.cpp:3282
bool valid_wheel_config() const
Definition: vehicle.cpp:4461
std::vector< int > wheelcache
Definition: vehicle.h:1843
void check_falling_or_floating()
point pivot_point() const
Definition: vehicle.cpp:5828
tileray face
Definition: vehicle.h:1973
void invalidate_mass()
Mark mass caches and pivot cache as dirty.
Definition: vehicle.cpp:6972
int part_count() const
Definition: vehicle.cpp:7079
bool collision(std::vector< veh_collision > &colls, const tripoint &dp, bool just_detect, bool bash_floor=false)
void precalc_mounts(int idir, units::angle dir, point pivot)
Definition: vehicle.cpp:3151
monster * get_pet(int p) const
Definition: vehicle.cpp:3263
vehicle_part & part(int part_num)
Definition: vehicle.cpp:7084
void handle_trap(const tripoint &p, int part)
tripoint global_part_pos3(const int &index) const
Get the coordinates of the studied part of the vehicle.
Definition: vehicle.cpp:3287
void shift_zlevel()
units::angle turn_dir
Definition: vehicle.h:1952
static const efftype_id effect_harnessed("harnessed")
auto offroad_str_req_cap(vehicle *veh) -> int
Definition: grab.cpp:40
auto get_vehicle_str_requirement(vehicle *veh) -> int
Definition: grab.cpp:76
auto make_scraping_noise(const tripoint &pos, const int volume) -> void
Definition: grab.cpp:27
static constexpr tripoint tripoint_zero
Definition: point.h:259
int dice(int number, int sides)
Definition: rng.cpp:85
std::array< tripoint, 2 > precalc
mount translated to face.dir [0] and turn_dir [1]
Definition: vehicle.h:372

References _, add_msg(), vehicle::adjust_zlevel(), vehicle::check_falling_or_floating(), vehicle::collision(), debugmsg, dice(), tileray::dir(), map::displace_vehicle(), effect_harnessed, vehicle::face, failed, monster::get_name(), vehicle::get_pet(), Character::get_str(), anonymous_namespace{grab.cpp}::get_vehicle_str_requirement(), vehicle::global_part_pos3(), vehicle::global_pos3(), avatar::grab(), player::grab_point, vehicle::handle_potential_theft(), vehicle::handle_trap(), Creature::has_effect(), tileray::init(), vehicle::invalidate_mass(), m, m_bad, m_debug, m_info, anonymous_namespace{grab.cpp}::make_scraping_noise(), Character::mod_pain(), Character::mod_stamina(), Creature::moves, vehicle::name, OBJECT_NONE, anonymous_namespace{grab.cpp}::offroad_str_req_cap(), one_in(), vehicle::part(), vehicle::part_count(), vehicle::pivot_point(), Character::pos(), vehicle_part::precalc, vehicle::precalc_mounts(), Character::setpos(), vehicle::shift_zlevel(), tripoint_zero, vehicle::turn(), vehicle::turn_dir, u, vehicle::valid_wheel_config(), map::veh_at(), veh_pointer_or_null(), vehicle::wheelcache, tripoint::x, tripoint::xy(), and tripoint::y.

Referenced by grabbed_move().

◆ handle_action()

bool game::handle_action ( )
private

Definition at line 1523 of file handle_action.cpp.

1524{
1525 std::string action;
1526 input_context ctxt;
1528 user_turn current_turn;
1529 // Check if we have an auto-move destination
1530 if( u.has_destination() ) {
1532 if( act == ACTION_NULL ) {
1533 add_msg( m_info, _( "Auto-move canceled" ) );
1535 return false;
1536 }
1537 } else if( u.has_destination_activity() ) {
1538 // starts destination activity after the player successfully reached his destination
1540 return false;
1541 } else {
1542 // No auto-move, ask player for input
1543 ctxt = get_player_input( action );
1544 }
1545
1546 const optional_vpart_position vp = m.veh_at( u.pos() );
1547 bool veh_ctrl = !u.is_dead_state() &&
1548 ( ( vp && vp->vehicle().player_in_control( u ) ) || remoteveh() != nullptr );
1549
1550 // If performing an action with right mouse button, co-ordinates
1551 // of location clicked.
1552 std::optional<tripoint> mouse_target;
1553
1554 if( uquit == QUIT_WATCH && action == "QUIT" ) {
1555 uquit = QUIT_DIED;
1556 return false;
1557 }
1558
1559 if( act == ACTION_NULL ) {
1561
1562 if( act == ACTION_KEYBINDINGS ) {
1563 // already handled by input context
1564 return false;
1565 }
1566
1567 if( act == ACTION_MAIN_MENU ) {
1568 if( uquit == QUIT_WATCH ) {
1569 return false;
1570 }
1571 // No auto-move actions have or can be set at this point.
1573 destination_preview.clear();
1575 if( act == ACTION_NULL ) {
1576 return false;
1577 }
1578 }
1579
1580 if( act == ACTION_ACTIONMENU ) {
1581 if( uquit == QUIT_WATCH ) {
1582 return false;
1583 }
1584 // No auto-move actions have or can be set at this point.
1586 destination_preview.clear();
1588 if( act == ACTION_NULL ) {
1589 return false;
1590 }
1591#if defined(__ANDROID__)
1592 if( get_option<bool>( "ANDROID_ACTIONMENU_AUTOADD" ) && ctxt.get_category() == "DEFAULTMODE" ) {
1593 add_best_key_for_action_to_quick_shortcuts( act, ctxt.get_category(), false );
1594 }
1595#endif
1596 }
1597
1598 if( act == ACTION_KEYBINDINGS ) {
1600 destination_preview.clear();
1601 act = ctxt.display_menu( true );
1602 if( act == ACTION_NULL ) {
1603 return false;
1604 }
1605 }
1606
1609 }
1610
1611 if( act == ACTION_SELECT || act == ACTION_SEC_SELECT ) {
1612 // Mouse button click
1613 if( veh_ctrl ) {
1614 // No mouse use in vehicle
1615 return false;
1616 }
1617
1618 if( u.is_dead_state() ) {
1619 // do not allow mouse actions while dead
1620 return false;
1621 }
1622
1623 const std::optional<tripoint> mouse_pos = ctxt.get_coordinates( w_terrain );
1624 if( !mouse_pos ) {
1625 return false;
1626 } else if( !u.sees( *mouse_pos ) ) {
1627 // Not clicked in visible terrain
1628 return false;
1629 }
1630 mouse_target = mouse_pos;
1631
1632 if( act == ACTION_SELECT ) {
1633 // Note: The following has the potential side effect of
1634 // setting auto-move destination state in addition to setting
1635 // act.
1636 if( !try_get_left_click_action( act, *mouse_target ) ) {
1637 return false;
1638 }
1639 } else if( act == ACTION_SEC_SELECT ) {
1640 if( !try_get_right_click_action( act, *mouse_target ) ) {
1641 return false;
1642 }
1643 }
1644 } else if( act != ACTION_TIMEOUT ) {
1645 // act has not been set for an auto-move, so clearing possible
1646 // auto-move destinations. Since initializing an auto-move with
1647 // the mouse may span across multiple actions, we do not clear the
1648 // auto-move destination if the action is only a timeout, as this
1649 // would require the user to double click quicker than the
1650 // timeout delay.
1652 destination_preview.clear();
1653 }
1654 }
1655
1656 if( act == ACTION_NULL ) {
1657 const input_event &&evt = ctxt.get_raw_input();
1658 if( !evt.sequence.empty() ) {
1659 const int ch = evt.get_first_input();
1660 const std::string &&name = inp_mngr.get_keyname( ch, evt.type, true );
1661 if( !get_option<bool>( "NO_UNKNOWN_COMMAND_MSG" ) ) {
1662 add_msg( m_info, _( "Unknown command: \"%s\" (%ld)" ), name, ch );
1663 if( const std::optional<std::string> hint =
1665 add_msg( m_info, _( "%s at any time to see and edit keybindings relevant to "
1666 "the current context." ),
1667 *hint );
1668 }
1669 }
1670 }
1671 return false;
1672 }
1673
1674 // This has no action unless we're in a special game mode.
1675 gamemode->pre_action( act );
1676
1677 int soffset = get_option<int>( "MOVE_VIEW_OFFSET" );
1678
1679 int before_action_moves = u.moves;
1680
1681 // These actions are allowed while deathcam is active. Registered in game::get_player_input
1682 if( uquit == QUIT_WATCH || !u.is_dead_state() ) {
1683 switch( act ) {
1686 break;
1687
1688 case ACTION_CENTER:
1691 break;
1692
1693 case ACTION_SHIFT_N:
1694 case ACTION_SHIFT_NE:
1695 case ACTION_SHIFT_E:
1696 case ACTION_SHIFT_SE:
1697 case ACTION_SHIFT_S:
1698 case ACTION_SHIFT_SW:
1699 case ACTION_SHIFT_W:
1700 case ACTION_SHIFT_NW: {
1701 static const std::map<action_id, std::pair<point, point>> shift_delta = {
1710 };
1712 shift_delta.at( act ).second * soffset : shift_delta.at( act ).first * soffset;
1713 }
1714 break;
1715
1716 case ACTION_LOOK:
1717 look_around();
1718 break;
1719
1720 case ACTION_KEYBINDINGS:
1721 // already handled by input context
1722 break;
1723
1724 default:
1725 break;
1726 }
1727 }
1728
1729 // actions allowed only while alive
1730 if( !u.is_dead_state() ) {
1731 switch( act ) {
1732 case ACTION_NULL:
1733 case NUM_ACTIONS:
1734 break; // dummy entries
1735 case ACTION_ACTIONMENU:
1736 case ACTION_MAIN_MENU:
1737 case ACTION_KEYBINDINGS:
1738 break; // handled above
1739
1740 case ACTION_TIMEOUT:
1741 if( check_safe_mode_allowed( false ) ) {
1743 }
1744 break;
1745
1746 case ACTION_PAUSE:
1747 if( check_safe_mode_allowed() ) {
1749 }
1750 break;
1751
1752 case ACTION_CYCLE_MOVE:
1754 break;
1755
1756 case ACTION_RESET_MOVE:
1758 break;
1759
1760 case ACTION_TOGGLE_RUN:
1762 break;
1763
1766 break;
1767
1770 break;
1771
1772 case ACTION_MOVE_FORTH:
1774 case ACTION_MOVE_RIGHT:
1776 case ACTION_MOVE_BACK:
1778 case ACTION_MOVE_LEFT:
1780 if( !u.get_value( "remote_controlling" ).empty() &&
1784 } else if( veh_ctrl ) {
1785 // vehicle control uses x for steering and y for ac/deceleration,
1786 // so no rotation needed
1788 } else {
1790 if( auto_travel_mode && !u.is_auto_moving() ) {
1791 for( int i = 0; i < SEEX; i++ ) {
1792 tripoint auto_travel_destination( u.posx() + dest_delta.x * ( SEEX - i ),
1793 u.posy() + dest_delta.y * ( SEEX - i ),
1794 u.posz() );
1796 auto_travel_destination,
1798 u.get_path_avoid() );
1799 if( !destination_preview.empty() ) {
1802 break;
1803 }
1804 }
1807 if( dest_next == point_zero ) {
1809 }
1810 dest_delta = dest_next;
1811 }
1812 if( !avatar_action::move( u, m, dest_delta ) ) {
1813 // auto-move should be canceled due to a failed move or obstacle
1815 }
1816 }
1817 break;
1818 case ACTION_MOVE_DOWN:
1819 if( u.is_mounted() ) {
1820 auto mon = u.mounted_creature.get();
1821 if( !mon->has_flag( MF_RIDEABLE_MECH ) ) {
1822 add_msg( m_info, _( "You can't go down stairs while you're riding." ) );
1823 break;
1824 }
1825 }
1826 if( !u.in_vehicle ) {
1827 vertical_move( -1, false );
1828 } else if( veh_ctrl && vp->vehicle().is_rotorcraft() ) {
1830 }
1831 break;
1832
1833 case ACTION_MOVE_UP:
1834 if( u.is_mounted() ) {
1835 auto mon = u.mounted_creature.get();
1836 if( !mon->has_flag( MF_RIDEABLE_MECH ) ) {
1837 add_msg( m_info, _( "You can't go down stairs while you're riding." ) );
1838 break;
1839 }
1840 }
1841 if( !u.in_vehicle ) {
1842 vertical_move( 1, false );
1843 } else if( veh_ctrl && vp->vehicle().is_rotorcraft() ) {
1845 } else if( veh_ctrl && vp->vehicle().has_part( "ROTOR" ) &&
1846 !vp->vehicle().has_sufficient_rotorlift() ) {
1847 add_msg( m_bad, _( "The rotors struggle to generate enough lift!" ) );
1848 }
1849 break;
1850
1851 case ACTION_OPEN:
1853 add_msg( m_info, _( "You can't open things while you're in your shell." ) );
1854 } else if( u.is_mounted() ) {
1855 add_msg( m_info, _( "You can't open things while you're riding." ) );
1856 } else {
1857 open();
1858 }
1859 break;
1860
1861 case ACTION_CLOSE:
1863 add_msg( m_info, _( "You can't close things while you're in your shell." ) );
1864 } else if( u.is_mounted() ) {
1865 auto mon = u.mounted_creature.get();
1866 if( !mon->has_flag( MF_RIDEABLE_MECH ) ) {
1867 add_msg( m_info, _( "You can't close things while you're riding." ) );
1868 }
1869 } else if( mouse_target ) {
1870 doors::close_door( m, u, *mouse_target );
1871 } else {
1872 close();
1873 }
1874 break;
1875
1876 case ACTION_SMASH:
1877 if( veh_ctrl ) {
1878 handbrake();
1879 } else if( u.has_active_mutation( trait_SHELL2 ) ) {
1880 add_msg( m_info, _( "You can't smash things while you're in your shell." ) );
1881 } else {
1882 smash();
1883 }
1884 break;
1885
1886 case ACTION_EXAMINE:
1888 add_msg( m_info, _( "You can't examine your surroundings while you're in your shell." ) );
1889 } else if( mouse_target ) {
1890 examine( *mouse_target );
1891 } else {
1892 examine();
1893 }
1894 break;
1895
1896 case ACTION_ADVANCEDINV:
1898 add_msg( m_info, _( "You can't move mass quantities while you're in your shell." ) );
1899 } else if( u.is_mounted() ) {
1900 add_msg( m_info, _( "You can't move mass quantities while you're riding." ) );
1901 } else {
1903 }
1904 break;
1905
1906 case ACTION_PICKUP:
1908 add_msg( m_info, _( "You can't pick anything up while you're in your shell." ) );
1909 } else if( u.is_mounted() ) {
1910 add_msg( m_info, _( "You can't pick anything up while you're riding." ) );
1911 } else if( mouse_target ) {
1912 pickup( *mouse_target );
1913 } else {
1914 pickup();
1915 }
1916 break;
1917
1918 case ACTION_PICKUP_FEET:
1920 add_msg( m_info, _( "You can't pick anything up while you're in your shell." ) );
1921 } else {
1922 pickup_feet();
1923 }
1924 break;
1925
1926 case ACTION_GRAB:
1928 add_msg( m_info, _( "You can't grab things while you're in your shell." ) );
1929 } else if( u.is_mounted() ) {
1930 add_msg( m_info, _( "You can't grab things while you're riding." ) );
1931 } else {
1932 grab();
1933 }
1934 break;
1935
1936 case ACTION_HAUL:
1938 add_msg( m_info, _( "You can't haul things while you're in your shell." ) );
1939 } else if( u.is_mounted() ) {
1940 add_msg( m_info, _( "You can't haul things while you're riding." ) );
1941 } else {
1942 haul();
1943 }
1944 break;
1945
1946 case ACTION_BUTCHER:
1948 add_msg( m_info, _( "You can't butcher while you're in your shell." ) );
1949 } else if( u.is_mounted() ) {
1950 add_msg( m_info, _( "You can't butcher while you're riding." ) );
1951 } else {
1952 butcher();
1953 }
1954 break;
1955
1956 case ACTION_CHAT:
1957 chat();
1958 break;
1959
1960 case ACTION_PEEK:
1962 add_msg( m_info, _( "You can't peek around corners while you're in your shell." ) );
1963 } else if( u.is_mounted() ) {
1964 add_msg( m_info, _( "You can't peek around corners while you're riding." ) );
1965 } else {
1966 peek();
1967 }
1968 break;
1969
1970 case ACTION_LIST_ITEMS:
1972 break;
1973
1974 case ACTION_ZONES:
1975 zones_manager();
1976 break;
1977
1978 case ACTION_LOOT:
1979 loot();
1980 break;
1981
1982 case ACTION_INVENTORY:
1984 break;
1985
1986 case ACTION_COMPARE:
1987 game_menus::inv::compare( u, std::nullopt );
1988 break;
1989
1990 case ACTION_ORGANIZE:
1992 break;
1993
1994 case ACTION_USE:
1995 // Shell-users are presumed to be able to mess with their inventories, etc
1996 // while in the shell. Eating, gear-changing, and item use are OK.
1998 break;
1999
2000 case ACTION_USE_WIELDED:
2002 break;
2003
2004 case ACTION_WEAR:
2005 wear();
2006 break;
2007
2008 case ACTION_TAKE_OFF:
2009 takeoff();
2010 break;
2011
2012 case ACTION_EAT:
2013 if( !avatar_action::eat_here( u ) ) {
2015 }
2016 break;
2017
2019 if( !avatar_action::eat_here( u ) ) {
2021 }
2022 break;
2023
2024 case ACTION_READ:
2025 // Shell-users are presumed to have the book just at an opening and read it that way
2026 read();
2027 break;
2028
2029 case ACTION_WIELD:
2031 break;
2032
2033 case ACTION_PICK_STYLE:
2034 u.martial_arts_data->pick_style( u );
2035 break;
2036
2037 case ACTION_RELOAD_ITEM:
2039 break;
2040
2043 break;
2044
2047 break;
2048
2049 case ACTION_UNLOAD:
2051 break;
2052
2053 case ACTION_MEND:
2055 break;
2056
2057 case ACTION_THROW: {
2058 item_location loc;
2059 avatar_action::plthrow( g->u, loc );
2060 break;
2061 }
2062
2063 case ACTION_FIRE:
2064 fire();
2065 break;
2066
2067 case ACTION_CAST_SPELL:
2068 cast_spell();
2069 break;
2070
2071 case ACTION_FIRE_BURST: {
2072 if( u.primary_weapon().gun_set_mode( gun_mode_id( "AUTO" ) ) ) {
2074 }
2075 break;
2076 }
2077
2079 if( u.is_armed() && u.primary_weapon().is_gun() && !u.primary_weapon().is_gunmod() ) {
2080 if( u.primary_weapon().gun_all_modes().size() > 1 ) {
2082 } else {
2083 add_msg( m_info, _( "Your %s has only one firing mode." ), u.primary_weapon().display_name() );
2084 }
2085 }
2086 break;
2087
2089 if( u.is_armed() && u.primary_weapon().is_gun() && !u.primary_weapon().is_gunmod() ) {
2091 }
2092 break;
2093
2094 case ACTION_DROP:
2095 // You CAN drop things to your own tile while in the shell.
2096 drop();
2097 break;
2098
2099 case ACTION_DIR_DROP:
2101 add_msg( m_info, _( "You can't drop things to another tile while you're in your shell." ) );
2102 } else {
2104 }
2105 break;
2106 case ACTION_BIONICS:
2107 show_bionics_ui( u );
2108 break;
2109 case ACTION_MUTATIONS:
2111 break;
2112
2113 case ACTION_SORT_ARMOR:
2115 break;
2116
2117 case ACTION_WAIT:
2118 wait();
2119 break;
2120
2121 case ACTION_CRAFT:
2123 add_msg( m_info, _( "You can't craft while you're in your shell." ) );
2124 } else if( u.is_mounted() ) {
2125 add_msg( m_info, _( "You can't craft while you're riding." ) );
2126 } else {
2127 u.craft();
2128 }
2129 break;
2130
2131 case ACTION_RECRAFT:
2133 add_msg( m_info, _( "You can't craft while you're in your shell." ) );
2134 } else if( u.is_mounted() ) {
2135 add_msg( m_info, _( "You can't craft while you're riding." ) );
2136 } else {
2137 u.recraft();
2138 }
2139 break;
2140
2141 case ACTION_LONGCRAFT:
2143 add_msg( m_info, _( "You can't craft while you're in your shell." ) );
2144 } else if( u.is_mounted() ) {
2145 add_msg( m_info, _( "You can't craft while you're riding." ) );
2146 } else {
2147 u.long_craft();
2148 }
2149 break;
2150
2151 case ACTION_DISASSEMBLE:
2152 if( u.controlling_vehicle ) {
2153 add_msg( m_info, _( "You can't disassemble items while driving." ) );
2154 } else if( u.is_mounted() ) {
2155 add_msg( m_info, _( "You can't disassemble items while you're riding." ) );
2156 } else {
2158 }
2159 break;
2160
2161 case ACTION_CONSTRUCT:
2162 if( u.in_vehicle ) {
2163 add_msg( m_info, _( "You can't construct while in a vehicle." ) );
2164 } else if( u.has_active_mutation( trait_SHELL2 ) ) {
2165 add_msg( m_info, _( "You can't construct while you're in your shell." ) );
2166 } else if( u.is_mounted() ) {
2167 add_msg( m_info, _( "You can't construct while you're riding." ) );
2168 } else {
2169 construction_menu( false );
2170 }
2171 break;
2172
2173 case ACTION_SLEEP:
2174 if( veh_ctrl ) {
2175 add_msg( m_info, _( "Vehicle control has moved, %s" ),
2176 press_x( ACTION_CONTROL_VEHICLE, _( "new binding is " ),
2177 _( "new default binding is '^'." ) ) );
2178 } else {
2179 sleep();
2180 }
2181 break;
2182
2185 add_msg( m_info, _( "You can't operate a vehicle while you're in your shell." ) );
2186 } else if( u.is_mounted() ) {
2187 u.dismount();
2188 } else {
2190 }
2191 break;
2192
2195 add_msg( m_info, auto_travel_mode ? _( "Auto travel mode ON!" ) : _( "Auto travel mode OFF!" ) );
2196 break;
2197
2199 if( safe_mode == SAFE_MODE_OFF ) {
2201 mostseen = 0;
2202 add_msg( m_info, _( "Safe mode ON!" ) );
2203 } else {
2206 add_msg( m_info, get_option<bool>( "AUTOSAFEMODE" )
2207 ? _( "Safe mode OFF! (Auto safe mode still enabled!)" ) : _( "Safe mode OFF!" ) );
2208 }
2212 }
2213 break;
2214
2216 auto &autosafemode_option = get_options().get_option( "AUTOSAFEMODE" );
2217 add_msg( m_info, autosafemode_option.value_as<bool>()
2218 ? _( "Auto safe mode OFF!" ) : _( "Auto safe mode ON!" ) );
2219 autosafemode_option.setNext();
2220 break;
2221 }
2222
2224 if( safe_mode == SAFE_MODE_STOP ) {
2225 add_msg( m_info, _( "Ignoring enemy!" ) );
2226 for( auto &elem : u.get_mon_visible().new_seen_mon ) {
2227 monster &critter = *elem;
2228 critter.ignoring = rl_dist( u.pos(), critter.pos() );
2229 }
2231 } else if( u.has_effect( effect_laserlocked ) ) {
2232 if( u.has_trait( trait_PROF_CHURL ) ) {
2233 add_msg( m_warning, _( "You make the sign of the cross." ) );
2234 } else {
2235 add_msg( m_info, _( "Ignoring laser targeting!" ) );
2236 }
2239 }
2240 break;
2241
2243 if( safe_mode == SAFE_MODE_STOP && !get_safemode().empty() ) {
2245 add_msg( m_info, _( "Creature whitelisted: %s" ), get_safemode().lastmon_whitelist );
2247 mostseen = 0;
2248 } else {
2249 get_safemode().show();
2250 }
2251 break;
2252
2253 case ACTION_SUICIDE:
2254 if( query_yn( _( "Commit suicide?" ) ) ) {
2255 if( query_yn( _( "REALLY commit suicide?" ) ) ) {
2256 u.apply_damage( &u, body_part_head, 99999 );
2257 u.moves = 0;
2258 u.place_corpse();
2260 }
2261 }
2262 break;
2263
2264 case ACTION_SAVE:
2265 if( query_yn( _( "Save and quit?" ) ) ) {
2266 if( save() ) {
2267 u.moves = 0;
2268 uquit = QUIT_SAVED;
2269 }
2270 }
2271 break;
2272
2273 case ACTION_QUICKSAVE:
2274 quicksave();
2275 return false;
2276
2277 case ACTION_QUICKLOAD:
2278 quickload();
2279 return false;
2280
2281 case ACTION_PL_INFO:
2283 break;
2284
2285 case ACTION_MAP:
2287 break;
2288
2289 case ACTION_SKY:
2290 if( m.is_outside( u.pos() ) ) {
2292 } else {
2293 add_msg( m_info, _( "You can't see the sky from here." ) );
2294 }
2295 break;
2296
2297 case ACTION_MISSIONS:
2298 list_missions();
2299 break;
2300
2301 case ACTION_SCORES:
2303 break;
2304
2305 case ACTION_DIARY:
2307 break;
2308
2309 case ACTION_FACTIONS:
2310 faction_manager_ptr->display();
2311 break;
2312
2313 case ACTION_MORALE:
2314 u.disp_morale();
2315 break;
2316
2317 case ACTION_MESSAGES:
2319 break;
2320
2321 case ACTION_HELP:
2323 break;
2324
2325 case ACTION_OPTIONS:
2326 get_options().show( true );
2327 break;
2328
2329 case ACTION_AUTOPICKUP:
2331 break;
2332
2333 case ACTION_AUTONOTES:
2335 break;
2336
2337 case ACTION_SAFEMODE:
2338 get_safemode().show();
2339 break;
2340
2343 break;
2344
2345 case ACTION_COLOR:
2346 all_colors.show_gui();
2347 break;
2348
2349 case ACTION_WORLD_MODS:
2350 world_generator->show_active_world_mods( world_generator->active_world->active_mod_order );
2351 break;
2352
2353 case ACTION_DEBUG:
2355 break; //don't do anything when sharing and not debugger
2356 }
2358 break;
2359
2362 break;
2363
2366 break;
2367
2370 break;
2371
2373 reload_tileset( []( std::string str ) {
2374 DebugLog( DL::Info, DC::Main ) << str;
2375 } );
2376 break;
2377
2379 get_options().get_option( "AUTO_FEATURES" ).setNext();
2380 get_options().save();
2381 //~ Auto Features are now ON/OFF
2382 add_msg( _( "%s are now %s." ),
2383 get_options().get_option( "AUTO_FEATURES" ).getMenuText(),
2384 get_option<bool>( "AUTO_FEATURES" ) ? _( "ON" ) : _( "OFF" ) );
2385 break;
2386
2388 get_options().get_option( "AUTO_PULP_BUTCHER" ).setNext();
2389 get_options().save();
2390 //~ Auto Pulp/Pulp Adjacent/Butcher is now set to x
2391 add_msg( _( "%s is now set to %s." ),
2392 get_options().get_option( "AUTO_PULP_BUTCHER" ).getMenuText(),
2393 get_options().get_option( "AUTO_PULP_BUTCHER" ).getValueName() );
2394 break;
2395
2397 get_options().get_option( "AUTO_MINING" ).setNext();
2398 get_options().save();
2399 //~ Auto Mining is now ON/OFF
2400 add_msg( _( "%s is now %s." ),
2401 get_options().get_option( "AUTO_MINING" ).getMenuText(),
2402 get_option<bool>( "AUTO_MINING" ) ? _( "ON" ) : _( "OFF" ) );
2403 break;
2404
2406 if( g->u.get_value( "THIEF_MODE" ) == "THIEF_ASK" ) {
2407 u.set_value( "THIEF_MODE", "THIEF_HONEST" );
2408 u.set_value( "THIEF_MODE_KEEP", "YES" );
2409 //~ Thief mode cycled between THIEF_ASK/THIEF_HONEST/THIEF_STEAL
2410 add_msg( _( "You will not pick up other peoples belongings." ) );
2411 } else if( g->u.get_value( "THIEF_MODE" ) == "THIEF_HONEST" ) {
2412 u.set_value( "THIEF_MODE", "THIEF_STEAL" );
2413 u.set_value( "THIEF_MODE_KEEP", "YES" );
2414 //~ Thief mode cycled between THIEF_ASK/THIEF_HONEST/THIEF_STEAL
2415 add_msg( _( "You will pick up also those things that belong to others!" ) );
2416 } else if( g->u.get_value( "THIEF_MODE" ) == "THIEF_STEAL" ) {
2417 u.set_value( "THIEF_MODE", "THIEF_ASK" );
2418 u.set_value( "THIEF_MODE_KEEP", "NO" );
2419 //~ Thief mode cycled between THIEF_ASK/THIEF_HONEST/THIEF_STEAL
2420 add_msg( _( "You will be reminded not to steal." ) );
2421 } else {
2422 // ERROR
2423 add_msg( _( "THIEF_MODE CONTAINED BAD VALUE [ %s ]!" ), g->u.get_value( "THIEF_MODE" ) );
2424 }
2425 break;
2426
2428 get_options().get_option( "AUTO_FORAGING" ).setNext();
2429 get_options().save();
2430 //~ Auto Foraging is now set to x
2431 add_msg( _( "%s is now set to %s." ),
2432 get_options().get_option( "AUTO_FORAGING" ).getMenuText(),
2433 get_options().get_option( "AUTO_FORAGING" ).getValueName() );
2434 break;
2435
2437 get_options().get_option( "AUTO_PICKUP" ).setNext();
2438 get_options().save();
2439 //~ Auto pickup is now set to x
2440 add_msg( _( "%s is now set to %s." ),
2441 get_options().get_option( "AUTO_PICKUP" ).getMenuText(),
2442 get_options().get_option( "AUTO_PICKUP" ).getValueName() );
2443 break;
2444
2447 break; //don't do anything when sharing and not debugger
2448 }
2449 display_scent();
2450 break;
2451
2454 break; //don't do anything when sharing and not debugger
2455 }
2456 display_scent();
2457 break;
2458
2461 break; //don't do anything when sharing and not debugger
2462 }
2464 break;
2467 break; //don't do anything when sharing and not debugger
2468 }
2470 break;
2473 break; //don't do anything when sharing and not debugger
2474 }
2476 break;
2477
2480 break; //don't do anything when sharing and not debugger
2481 }
2483 break;
2484
2487 break; //don't do anything when sharing and not debugger
2488 }
2490 break;
2491
2494 break; //don't do anything when sharing and not debugger
2495 }
2497 break;
2498
2500 g->debug_submap_grid_overlay = !g->debug_submap_grid_overlay;
2501 break;
2502
2505 break;
2506
2509 break; //don't do anything when sharing and not debugger
2510 }
2512 if( debug_mode ) {
2513 add_msg( m_info, _( "Debug mode ON!" ) );
2514 } else {
2515 add_msg( m_info, _( "Debug mode OFF!" ) );
2516 }
2517 break;
2518
2519 case ACTION_ZOOM_IN:
2520 zoom_in();
2522 break;
2523
2524 case ACTION_ZOOM_OUT:
2525 zoom_out();
2527 break;
2528
2529 case ACTION_ITEMACTION:
2531 break;
2532
2533 case ACTION_AUTOATTACK:
2535 break;
2536
2537 default:
2538 break;
2539 }
2540 }
2541 if( act != ACTION_TIMEOUT ) {
2542 u.mod_moves( -current_turn.moves_elapsed() );
2543 }
2544 gamemode->post_action( act );
2545
2546 u.movecounter = ( !u.is_dead_state() ? ( before_action_moves - u.moves ) : 0 );
2547 dbg( DL::Info ) << string_format( "%s: [%d] %d - %d = %d", action_ident( act ),
2548 to_turn<int>( calendar::turn ), before_action_moves, u.movecounter, u.moves );
2549 return ( !u.is_dead_state() );
2550}
bool can_action_change_worldstate(const action_id act)
Lookup whether an action can affect the state of the game world.
Definition: action.cpp:352
action_id look_up_action(const std::string &ident)
Lookup an action ID by its unique string identifier.
Definition: action.cpp:423
action_id handle_main_menu()
Show in-game main menu.
Definition: action.cpp:911
point get_delta_from_movement_action(const action_id act, const iso_rotate rot)
Definition: action.cpp:512
std::optional< std::string > press_x_if_bound(action_id act)
Definition: action.cpp:474
action_id handle_action_menu()
Show the action menu.
Definition: action.cpp:687
@ ACTION_SAFEMODE
Open safemode manager.
Definition: action.h:263
@ ACTION_PEEK
Peek through something (e.g.
Definition: action.h:117
@ ACTION_OPEN
Open an item (e.g.
Definition: action.h:95
@ ACTION_CRAFT
Open crafting menu.
Definition: action.h:195
@ ACTION_DROP
Open the drop-item menu.
Definition: action.h:177
@ ACTION_READ
Open the read menu.
Definition: action.h:149
@ ACTION_TOGGLE_AUTO_PICKUP
Turn auto pickup on/off.
Definition: action.h:309
@ ACTION_MOVE_BACK_LEFT
Move towards bottom-left of screen / decelerate and steer left.
Definition: action.h:47
@ ACTION_ZOOM_IN
Zoom view out.
Definition: action.h:287
@ ACTION_EAT
Open the default consume item menu.
Definition: action.h:145
@ ACTION_SMASH
Smash something.
Definition: action.h:99
@ ACTION_ADVANCEDINV
Open the advanced inventory screen.
Definition: action.h:131
@ ACTION_QUICKSAVE
Quicksave the game.
Definition: action.h:223
@ ACTION_HELP
Display help screen.
Definition: action.h:249
@ ACTION_MESSAGES
Display messages screen.
Definition: action.h:247
@ ACTION_ZONES
Open the zone manager.
Definition: action.h:121
@ ACTION_TOGGLE_PIXEL_MINIMAP
Turn pixel minimap on/off.
Definition: action.h:293
@ ACTION_USE
Open the use menu.
Definition: action.h:137
@ ACTION_QUICKLOAD
Quickload the game.
Definition: action.h:225
@ ACTION_LIST_ITEMS
List items and monsters in a given square.
Definition: action.h:119
@ ACTION_DEBUG
Open debug menu.
Definition: action.h:277
@ ACTION_OPTIONS
Display options window.
Definition: action.h:257
@ ACTION_MOVE_FORTH
Move towards top of screen / accelerate.
Definition: action.h:37
@ ACTION_PICK_STYLE
Open the martial-arts style menu.
Definition: action.h:153
@ ACTION_CONSTRUCT
Open construct menu.
Definition: action.h:201
@ ACTION_MOVE_FORTH_RIGHT
Move towards top-right of screen / accelerate and steer right.
Definition: action.h:39
@ ACTION_SORT_ARMOR
Open the armor sorting menu.
Definition: action.h:185
@ ACTION_OPEN_CONSUME
Open the custom consume item menu.
Definition: action.h:147
@ ACTION_MORALE
Display morale effects screen.
Definition: action.h:245
@ ACTION_NULL
Invalid action used for various lookup errors.
Definition: action.h:20
@ ACTION_RESET_MOVE
Reset movement mode to walk
Definition: action.h:59
@ ACTION_CHAT
Chat with something.
Definition: action.h:113
@ ACTION_RELOAD_WIELDED
Attempt to reload wielded object.
Definition: action.h:159
@ ACTION_MOVE_DOWN
Descend a staircase.
Definition: action.h:53
@ ACTION_MISSIONS
Display missions screen.
Definition: action.h:239
@ ACTION_AUTONOTES
Open autonotes manager.
Definition: action.h:261
@ ACTION_WIELD
Open the wield menu.
Definition: action.h:151
@ ACTION_THROW
Open the throw menu.
Definition: action.h:165
@ ACTION_TOGGLE_AUTO_MINING
Turn auto mining on/off.
Definition: action.h:305
@ ACTION_INVENTORY
Open the primary inventory screen.
Definition: action.h:129
@ ACTION_TOGGLE_AUTOSAFE
Turn automatic triggering of safemode on/off.
Definition: action.h:213
@ ACTION_OPEN_MOVEMENT
Open movement mode menu.
Definition: action.h:65
@ ACTION_COMPARE
Open the item compare screen.
Definition: action.h:133
@ ACTION_SCORES
Display scores screen.
Definition: action.h:241
@ ACTION_BUTCHER
Butcher or disassemble objects in current square.
Definition: action.h:111
@ ACTION_SEC_SELECT
Click on a point with secondary mouse button (usually right button)
Definition: action.h:27
@ ACTION_TOGGLE_CROUCH
Toggle crouch on/off.
Definition: action.h:63
@ ACTION_TOGGLE_HOUR_TIMER
Toggle timing of the game hours.
Definition: action.h:325
@ ACTION_SELECT
Click on a point with primary mouse button (usually left button)
Definition: action.h:25
@ ACTION_MAIN_MENU
Display main menu.
Definition: action.h:251
@ ACTION_DISPLAY_SUBMAP_GRID
Toggle submap grid overlay.
Definition: action.h:323
@ ACTION_WAIT
Open wait menu.
Definition: action.h:193
@ ACTION_ACTIONMENU
Open the action menu.
Definition: action.h:289
@ ACTION_DISASSEMBLE
Open disassemble menu.
Definition: action.h:203
@ ACTION_LOOT
Sort out the loot.
Definition: action.h:123
@ ACTION_TOGGLE_FULLSCREEN
Toggle full-screen mode.
Definition: action.h:275
@ ACTION_MAP
Display over-map.
Definition: action.h:235
@ ACTION_MEND
Open the mending menu (e.g.
Definition: action.h:163
@ ACTION_TOGGLE_THIEF_MODE
Toggle permanent attitude to stealing.
Definition: action.h:215
@ ACTION_USE_WIELDED
Use currently wielded item.
Definition: action.h:139
@ ACTION_PL_INFO
Display player status screen.
Definition: action.h:233
@ ACTION_DISPLAY_SCENT_TYPE
Toggle scent type map.
Definition: action.h:281
@ ACTION_TOGGLE_AUTO_FORAGING
Turn auto foraging on/off.
Definition: action.h:307
@ ACTION_FIRE_BURST
Burst-fire the current weapon.
Definition: action.h:169
@ ACTION_BIONICS
Open the bionics menu.
Definition: action.h:181
@ ACTION_CONTROL_VEHICLE
Open vehicle control menu.
Definition: action.h:207
@ ACTION_SAVE
Save the game and quit.
Definition: action.h:221
@ ACTION_MOVE_UP
Ascend a staircase.
Definition: action.h:55
@ ACTION_TOGGLE_PANEL_ADM
Turn admin panel on/off.
Definition: action.h:295
@ ACTION_TOGGLE_AUTO_PULP_BUTCHER
Change auto pulp/butcher mode.
Definition: action.h:303
@ ACTION_TOGGLE_AUTO_TRAVEL_MODE
Turn auto travel mode on/off.
Definition: action.h:209
@ ACTION_COLOR
Open color manager.
Definition: action.h:265
@ ACTION_TIMEOUT
Input timeout.
Definition: action.h:35
@ ACTION_TOGGLE_RUN
Toggle run on/off.
Definition: action.h:61
@ ACTION_FACTIONS
Display factions screen.
Definition: action.h:243
@ ACTION_GRAB
Grab or let go of an object.
Definition: action.h:107
@ ACTION_MOVE_BACK
Move towards bottom of screen / decelerate.
Definition: action.h:45
@ ACTION_CAST_SPELL
Cast a spell (only if any spells are known)
Definition: action.h:175
@ ACTION_DIR_DROP
Drop items in a given direction.
Definition: action.h:179
@ ACTION_AUTOATTACK
Auto select and attack hostile creature within range.
Definition: action.h:187
@ ACTION_CYCLE_MOVE
Cycle run/walk/crouch mode.
Definition: action.h:57
@ ACTION_SKY
Show sky state for trying to predict weather.
Definition: action.h:237
@ ACTION_FIRE
Fire the wielded weapon, or open fire menu if none.
Definition: action.h:167
@ ACTION_PAUSE
Pause an on-going activity.
Definition: action.h:33
@ ACTION_MOVE_BACK_RIGHT
Move towards bottom-right of screen / decelerate and steer right.
Definition: action.h:43
@ ACTION_MUTATIONS
Open the mutations menu.
Definition: action.h:183
@ ACTION_HAUL
Haul pile of items, or let go of them.
Definition: action.h:109
@ ACTION_MOVE_RIGHT
Move / steer right.
Definition: action.h:41
@ ACTION_SLEEP
Open sleep menu.
Definition: action.h:205
@ ACTION_ITEMACTION
Open the item uses menu.
Definition: action.h:291
@ ACTION_MOVE_LEFT
Move / steer left.
Definition: action.h:49
@ ACTION_SELECT_DEFAULT_AMMO
Change default ammo for current weapon.
Definition: action.h:173
@ ACTION_AUTOPICKUP
Open autopickup manager.
Definition: action.h:259
@ ACTION_SUICIDE
Commit suicide.
Definition: action.h:227
@ NUM_ACTIONS
Not an action, serves as count of enumerated actions.
Definition: action.h:327
@ ACTION_ZOOM_OUT
Zoom view in.
Definition: action.h:285
@ ACTION_SELECT_FIRE_MODE
Change fire mode of the current weapon.
Definition: action.h:171
@ ACTION_UNLOAD
Open the unload item (e.g.
Definition: action.h:161
@ ACTION_RECRAFT
Repeat last craft command.
Definition: action.h:197
@ ACTION_TAKE_OFF
Open the take-off clothing selection menu.
Definition: action.h:143
@ ACTION_PICKUP_FEET
Pick up items from current square.
Definition: action.h:105
@ ACTION_TOGGLE_AUTO_FEATURES
Turn auto features on/off.
Definition: action.h:301
@ ACTION_WORLD_MODS
Open active world mods.
Definition: action.h:267
@ ACTION_TOGGLE_DEBUG_MODE
Toggle debug mode.
Definition: action.h:283
@ ACTION_ORGANIZE
Swap inventory letters.
Definition: action.h:135
@ ACTION_MOVE_FORTH_LEFT
Move towards top-left of screen / accelerate and steer left.
Definition: action.h:51
@ ACTION_RELOAD_TILESET
Reload current tileset.
Definition: action.h:299
@ ACTION_CLOSE
Close an item (e.g.
Definition: action.h:97
@ ACTION_RELOAD_WEAPON
Attempt to reload wielded weapon, then fall back to the load item select menu.
Definition: action.h:157
@ ACTION_RELOAD_ITEM
Open the load item (e.g.
Definition: action.h:155
@ ACTION_PICKUP
Pick up items from current/adjacent squares.
Definition: action.h:103
@ ACTION_LONGCRAFT
Open batch crafting menu.
Definition: action.h:199
@ ACTION_DISTRACTION_MANAGER
Open distraction manager.
Definition: action.h:269
@ ACTION_WEAR
Open the wear clothing selection menu.
Definition: action.h:141
@ ACTION_DIARY
Display diary window.
Definition: action.h:253
void create_advanced_inv()
void show_armor_layers_ui(Character &who)
auto_notes::auto_note_settings & get_auto_notes_settings()
Definition: auto_note.cpp:386
auto_pickup::player_settings & get_auto_pickup()
Definition: auto_pickup.cpp:38
void show_bionics_ui(Character &who)
Definition: bionics_ui.cpp:537
const bodypart_str_id body_part_head("head")
bool tile_iso
Using isometric tileset.
bool debug_mode
Extended debugging mode, can be toggled during game.
bool has_active_mutation(const trait_id &b) const
Definition: mutation.cpp:365
pimpl< character_martial_arts > martial_arts_data
Definition: character.h:1584
bool has_active_item(const itype_id &id) const
Whether the player carries an active item of the given item type.
Definition: character.cpp:2502
void place_corpse()
std::set< tripoint > get_path_avoid() const override
Returns a set of points we do not want to path through.
Definition: character.cpp:9936
bool has_destination_activity() const
bool is_auto_moving() const
void start_destination_activity()
action_id get_next_auto_move_direction()
item & primary_weapon()
Legacy code hack, don't use.
Definition: melee.cpp:154
const pathfinding_settings & get_pathfinding_settings() const override
Returns settings for pathfinding.
Definition: character.cpp:9950
bool is_armed() const
Returns true if the character is wielding something.
Definition: melee.cpp:177
void dismount()
Definition: character.cpp:1182
void set_value(const std::string &key, const std::string &value)
Definition: creature.cpp:1352
std::string get_value(const std::string &key) const
Definition: creature.cpp:1362
void mod_moves(int nmoves)
Definition: creature.cpp:1429
void cycle_move_mode()
Definition: avatar.cpp:1187
void toggle_map_memory()
Definition: avatar.cpp:122
void toggle_crouch_mode()
Definition: avatar.cpp:1171
void toggle_run_mode()
Definition: avatar.cpp:1162
void disp_morale()
Provides the window and detailed morale data.
Definition: avatar.cpp:1001
void reset_move_mode()
Definition: avatar.cpp:1180
static void show_diary_ui(diary *c_diary)
Definition: diary_ui.cpp:164
void item_action_menu()
void display_radiation()
Definition: game.cpp:11262
void list_missions()
Definition: mission_ui.cpp:22
input_context get_player_input(std::string &action)
bool try_get_left_click_action(action_id &act, const tripoint &mouse_target)
Definition: game.cpp:2302
void set_safe_mode(safe_mode_type mode)
Definition: game.cpp:8627
void reload_tileset(std::function< void(std::string)> out)
Definition: game.cpp:429
void pickup_feet()
Definition: game.cpp:5627
void zones_manager()
Definition: game.cpp:6100
int turnssincelastmon
Definition: game.h:1020
void display_visibility()
Definition: game.cpp:11176
void display_scent()
Definition: game.cpp:11141
bool save()
Returns false if saving failed.
Definition: game.cpp:2737
void butcher()
Definition: game.cpp:8309
void display_temperature()
Definition: game.cpp:11162
bool auto_travel_mode
Definition: game.h:1017
void zoom_out()
Definition: game.cpp:7050
void toggle_pixel_minimap()
Definition: game.cpp:418
void toggle_debug_hour_timer()
Definition: game.cpp:11208
void display_transparency()
Definition: game.cpp:11269
void list_items_monsters()
Definition: game.cpp:7228
void chat()
Definition: npctalk.cpp:396
void quickload()
Definition: game.cpp:11304
void pickup()
Definition: game.cpp:5605
void vertical_move(int z, bool force, bool peeking=false)
Moves the player vertically.
Definition: game.cpp:9975
void open_consume_item_menu()
void display_lighting()
Definition: game.cpp:11236
void control_vehicle()
Definition: game.cpp:5174
void peek()
Definition: game.cpp:5634
void drop()
Definition: game.cpp:8047
bool try_get_right_click_action(action_id &act, const tripoint &mouse_target)
Definition: game.cpp:2330
bool check_safe_mode_allowed(bool repeat_safe_mode_warnings=true)
Check whether movement is allowed according to safe mode settings.
Definition: game.cpp:8565
void zoom_in()
Definition: game.cpp:7062
void toggle_fullscreen()
Definition: game.cpp:408
void display_vehicle_ai()
Definition: game.cpp:11169
void mark_main_ui_adaptor_resize() const
Definition: game.cpp:2988
void drop_in_direction()
Definition: game.cpp:8052
void display_help()
Definition: help.cpp:140
input_event get_raw_input()
Temporary method to retrieve the raw input received, so that input_contexts can be used in screens wh...
Definition: input.cpp:1293
action_id display_menu(bool permit_execute_action=false)
Displays the possible actions in the current context and their keybindings.
Definition: input.cpp:993
std::optional< tripoint > get_coordinates(const catacurses::window &capture_win_)
Get the coordinates associated with the last mouse click (if any).
Definition: input.cpp:1332
std::string get_keyname(int ch, input_event_t inp_type, bool portable=false) const
Get the key name associated with the given keyboard keycode.
Definition: input.cpp:410
bool is_gun() const
Can this item be used to perform a ranged attack?
Definition: item.cpp:6517
void gun_cycle_mode()
Switch to the next available firing mode.
Definition: item.cpp:7920
std::string display_name(unsigned int quantity=1) const
Returns the item name and the charges or contained charges (if the item can have charges at all).
Definition: item.cpp:4820
bool is_gunmod() const
Definition: item.cpp:6547
std::map< gun_mode_id, gun_mode > gun_all_modes() const
Get all possible modes for this gun inclusive of any attached gunmods.
Definition: item.cpp:7839
bool gun_set_mode(const gun_mode_id &mode)
Try to set the mode for a gun, returning false if no such mode is possible.
Definition: item.cpp:7911
bool is_outside(const tripoint &p) const
Definition: map.cpp:2625
std::vector< tripoint > route(const tripoint &f, const tripoint &t, const pathfinding_settings &settings, const std::set< tripoint > &pre_closed={{ }}) const
Calculate the best path using A*.
const tripoint & pos() const override
Definition: monster.cpp:252
short ignoring
Definition: monster.h:505
cOpt & get_option(const std::string &name)
Definition: options.cpp:3386
std::string show(bool ingame=false, bool world_options_only=false, const std::function< bool()> &on_quit=nullptr)
Definition: options.cpp:2763
void show_adm()
Definition: panels.cpp:2298
void craft(const tripoint &loc=tripoint_zero)
Start various types of crafts.
Definition: crafting.cpp:341
int movecounter
Definition: player.h:247
void recraft(const tripoint &loc=tripoint_zero)
Definition: crafting.cpp:352
void long_craft(const tripoint &loc=tripoint_zero)
Definition: crafting.cpp:361
void add_rule(const std::string &rule_in, Creature::Attitude attitude_in, int proximity_in, rule_state state_in)
void show()
Definition: safemode_ui.cpp:39
int moves_elapsed()
#define all_colors
Definition: color.h:15
std::optional< construction_id > construction_menu(const bool blueprint)
@ Info
Information (default: enabled).
@ Main
Generic messages related to game startup and operation.
#define DebugLog(lev, cl)
DebugLog.
Definition: debug.h:274
@ RULE_WHITELISTED
Definition: enums.h:53
@ SAFE_MODE_OFF
Definition: game.h:77
@ QUIT_SAVED
Definition: game.h:70
static void open_movement_mode_menu()
static void smash()
static void open()
static void rcdrive(point d)
#define dbg(x)
static void takeoff()
static void read()
static void wait()
static const efftype_id effect_laserlocked("laserlocked")
static void wear()
static void close()
static const bionic_id bio_remote("bio_remote")
static void pldrive(const tripoint &p)
static void haul()
static const trait_id trait_SHELL2("SHELL2")
static const trait_id trait_PROF_CHURL("PROF_CHURL")
static void cast_spell()
static void loot()
static void fire()
static void grab()
static const itype_id itype_radiocontrol("radiocontrol")
help & get_help()
Definition: help.cpp:30
void show_mutations_ui(Character &who)
bool isDebugger()
Definition: mapsharing.cpp:65
bool isCompetitive()
Definition: mapsharing.cpp:35
void reload_wielded(bool prompt=false)
Reload wielded item.
void reload_item()
Prompt to reload some item.
void use_item(avatar &you, item_location &loc)
bool eat_here(avatar &you)
void wield()
Prompt to wield some item.
void plthrow(avatar &you, item_location loc, const std::optional< tripoint > &blind_throw_from_pos=std::nullopt)
void autoattack(avatar &you, map &m)
void eat(avatar &you)
Eat food or fuel 'E' (or 'a')
void fire_wielded_weapon(avatar &you)
Checks if the wielded weapon is a gun and can be fired then starts interactive aiming.
void reload_weapon(bool try_everything=true)
Reload a wielded gun/tool.
void mend(avatar &you, item_location loc)
void unload(avatar &you)
Prompts to unload some item.
void use_item(avatar &you, item_location loc)
Use a tool at given location.
void disp_info(Character &ch)
Handles and displays detailed character info for the '@' screen.
void do_pause(Character &who)
Do pause action ('.
void debug()
void close_door(map &m, Character &who, const tripoint &closep)
Handles deducting moves, printing messages (only non-NPCs cause messages), actually closing it,...
Definition: gates.cpp:256
void common(avatar &you)
void compare(player &p, const std::optional< tripoint > &offset)
void swap_letters(player &p)
void prompt_select_default_ammo_for(avatar &u, const item &w)
Prompts to select default ammo compatible with provided gun.
Definition: ranged.cpp:3799
void display_visible_weather()
Display overmap like with display() and display the weather that is within line of sight.
void display()
Display overmap centered at the player's position.
options_manager & get_options()
Definition: options.cpp:141
T get_option(const std::string &name)
Definition: options.h:368
static constexpr point point_south_west
Definition: point.h:267
static constexpr point point_north_east
Definition: point.h:263
static constexpr point point_north_west
Definition: point.h:269
@ sleep
Will recharge only when character is asleep.
An instance of an input, like a keypress etc.
Definition: input.h:91
std::vector< int > sequence
Definition: input.h:97
int get_first_input() const
Definition: input.cpp:100
input_event_t type
Definition: input.h:92
void handbrake()

References _, Creature::A_ANY, achievements_tracker_ptr, act, action, ACTION_ACTIONMENU, ACTION_ADVANCEDINV, ACTION_AUTOATTACK, ACTION_AUTONOTES, ACTION_AUTOPICKUP, ACTION_BIONICS, ACTION_BUTCHER, ACTION_CAST_SPELL, ACTION_CENTER, ACTION_CHAT, ACTION_CLOSE, ACTION_COLOR, ACTION_COMPARE, ACTION_CONSTRUCT, ACTION_CONTROL_VEHICLE, ACTION_CRAFT, ACTION_CYCLE_MOVE, ACTION_DEBUG, ACTION_DIARY, ACTION_DIR_DROP, ACTION_DISASSEMBLE, ACTION_DISPLAY_LIGHTING, ACTION_DISPLAY_RADIATION, ACTION_DISPLAY_SCENT, ACTION_DISPLAY_SCENT_TYPE, ACTION_DISPLAY_SUBMAP_GRID, ACTION_DISPLAY_TEMPERATURE, ACTION_DISPLAY_TRANSPARENCY, ACTION_DISPLAY_VEHICLE_AI, ACTION_DISPLAY_VISIBILITY, ACTION_DISTRACTION_MANAGER, ACTION_DROP, ACTION_EAT, ACTION_EXAMINE, ACTION_FACTIONS, ACTION_FIRE, ACTION_FIRE_BURST, ACTION_GRAB, ACTION_HAUL, ACTION_HELP, action_ident(), ACTION_IGNORE_ENEMY, ACTION_INVENTORY, ACTION_ITEMACTION, ACTION_KEYBINDINGS, ACTION_LIST_ITEMS, ACTION_LONGCRAFT, ACTION_LOOK, ACTION_LOOT, ACTION_MAIN_MENU, ACTION_MAP, ACTION_MEND, ACTION_MESSAGES, ACTION_MISSIONS, ACTION_MORALE, ACTION_MOVE_BACK, ACTION_MOVE_BACK_LEFT, ACTION_MOVE_BACK_RIGHT, ACTION_MOVE_DOWN, ACTION_MOVE_FORTH, ACTION_MOVE_FORTH_LEFT, ACTION_MOVE_FORTH_RIGHT, ACTION_MOVE_LEFT, ACTION_MOVE_RIGHT, ACTION_MOVE_UP, ACTION_MUTATIONS, ACTION_NULL, ACTION_OPEN, ACTION_OPEN_CONSUME, ACTION_OPEN_MOVEMENT, ACTION_OPTIONS, ACTION_ORGANIZE, ACTION_PAUSE, ACTION_PEEK, ACTION_PICK_STYLE, ACTION_PICKUP, ACTION_PICKUP_FEET, ACTION_PL_INFO, ACTION_QUICKLOAD, ACTION_QUICKSAVE, ACTION_READ, ACTION_RECRAFT, ACTION_RELOAD_ITEM, ACTION_RELOAD_TILESET, ACTION_RELOAD_WEAPON, ACTION_RELOAD_WIELDED, ACTION_RESET_MOVE, ACTION_SAFEMODE, ACTION_SAVE, ACTION_SCORES, ACTION_SEC_SELECT, ACTION_SELECT, ACTION_SELECT_DEFAULT_AMMO, ACTION_SELECT_FIRE_MODE, ACTION_SHIFT_E, ACTION_SHIFT_N, ACTION_SHIFT_NE, ACTION_SHIFT_NW, ACTION_SHIFT_S, ACTION_SHIFT_SE, ACTION_SHIFT_SW, ACTION_SHIFT_W, ACTION_SKY, ACTION_SLEEP, ACTION_SMASH, ACTION_SORT_ARMOR, ACTION_SUICIDE, ACTION_TAKE_OFF, ACTION_THROW, ACTION_TIMEOUT, ACTION_TOGGLE_AUTO_FEATURES, ACTION_TOGGLE_AUTO_FORAGING, ACTION_TOGGLE_AUTO_MINING, ACTION_TOGGLE_AUTO_PICKUP, ACTION_TOGGLE_AUTO_PULP_BUTCHER, ACTION_TOGGLE_AUTO_TRAVEL_MODE, ACTION_TOGGLE_AUTOSAFE, ACTION_TOGGLE_CROUCH, ACTION_TOGGLE_DEBUG_MODE, ACTION_TOGGLE_FULLSCREEN, ACTION_TOGGLE_HOUR_TIMER, ACTION_TOGGLE_MAP_MEMORY, ACTION_TOGGLE_PANEL_ADM, ACTION_TOGGLE_PIXEL_MINIMAP, ACTION_TOGGLE_RUN, ACTION_TOGGLE_SAFEMODE, ACTION_TOGGLE_THIEF_MODE, ACTION_UNLOAD, ACTION_USE, ACTION_USE_WIELDED, ACTION_WAIT, ACTION_WEAR, ACTION_WHITELIST_ENEMY, ACTION_WIELD, ACTION_WORLD_MODS, ACTION_ZONES, ACTION_ZOOM_IN, ACTION_ZOOM_OUT, add_msg(), safemode::add_rule(), all_colors, Character::apply_damage(), auto_travel_mode, avatar_action::autoattack(), bio_remote, body_part_head, butcher(), can_action_change_worldstate(), cast_spell(), chat(), check_safe_mode_allowed(), Character::clear_destination(), close(), doors::close_door(), game_menus::inv::common(), game_menus::inv::compare(), construction_menu(), control_vehicle(), Character::controlling_vehicle, player::craft(), create_advanced_inv(), avatar::cycle_move_mode(), dbg, debug_menu::debug(), debug_mode, DebugLog, destination_preview, crafting::disassemble(), Character::dismount(), character_display::disp_info(), avatar::disp_morale(), ui::omap::display(), help::display_help(), display_lighting(), input_context::display_menu(), Messages::display_messages(), item::display_name(), display_radiation(), display_scent(), display_temperature(), display_transparency(), display_vehicle_ai(), display_visibility(), ui::omap::display_visible_weather(), character_funcs::do_pause(), driving_view_offset, drop(), drop_in_direction(), avatar_action::eat(), avatar_action::eat_here(), effect_laserlocked, examine(), faction_manager_ptr, fire(), avatar_action::fire_wielded_weapon(), g, gamemode, get_auto_notes_settings(), get_auto_pickup(), avatar::get_avatar_diary(), input_context::get_coordinates(), get_delta_from_movement_action(), get_distraction_manager(), input_event::get_first_input(), get_help(), input_manager::get_keyname(), get_kill_tracker(), panel_manager::get_manager(), avatar::get_mon_visible(), Character::get_next_auto_move_direction(), options_manager::get_option(), get_option(), get_options(), Character::get_path_avoid(), Character::get_pathfinding_settings(), get_player_input(), input_context::get_raw_input(), get_safemode(), Creature::get_value(), grab(), item::gun_all_modes(), item::gun_cycle_mode(), item::gun_set_mode(), handbrake(), handle_action_menu(), handle_main_menu(), Character::has_active_bionic(), Character::has_active_item(), Character::has_active_mutation(), Character::has_destination(), Character::has_destination_activity(), Creature::has_effect(), Character::has_trait(), haul(), monster::ignoring, Character::in_vehicle, Info, inp_mngr, Character::is_armed(), Character::is_auto_moving(), Character::is_dead_state(), item::is_gun(), item::is_gunmod(), Character::is_mounted(), map::is_outside(), MAP_SHARING::isCompetitive(), MAP_SHARING::isDebugger(), item_action_menu(), itype_radiocontrol, list_items_monsters(), list_missions(), player::long_craft(), look_around(), look_up_action(), loot(), m, m_bad, m_info, m_warning, Main, mark_main_ui_adaptor_resize(), Character::martial_arts_data, avatar_action::mend(), MF_RIDEABLE_MECH, Creature::mod_moves(), mostseen, Character::mounted_creature, avatar_action::move(), player::movecounter, Creature::moves, user_turn::moves_elapsed(), om_direction::name(), monster_visible_info::new_seen_mon, no, NUM_ACTIONS, open(), open_consume_item_menu(), open_movement_mode_menu(), peek(), pickup(), pickup_feet(), Character::place_corpse(), pldrive(), avatar_action::plthrow(), point_east, point_north, point_north_east, point_north_west, point_south, point_south_east, point_south_west, point_west, point_zero, Character::pos(), monster::pos(), Character::posx(), Character::posy(), Character::posz(), press_x(), press_x_if_bound(), Character::primary_weapon(), ranged::prompt_select_default_ammo_for(), query_yn(), quickload(), quicksave(), QUIT_DIED, QUIT_SAVED, QUIT_SUICIDE, QUIT_WATCH, rcdrive(), read(), player::recraft(), avatar_action::reload_item(), reload_tileset(), avatar_action::reload_weapon(), avatar_action::reload_wielded(), remoteveh(), Creature::remove_effect(), avatar::reset_move_mode(), rl_dist(), map::route(), RULE_WHITELISTED, safe_mode, SAFE_MODE_OFF, SAFE_MODE_ON, SAFE_MODE_STOP, safe_mode_warning_logged, save(), options_manager::save(), Character::sees(), SEEX, input_event::sequence, Character::set_destination(), set_safe_mode(), Creature::set_value(), options_manager::cOpt::setNext(), auto_pickup::player_settings::show(), distraction_manager::distraction_manager_gui::show(), safemode::show(), options_manager::show(), panel_manager::show_adm(), show_armor_layers_ui(), show_bionics_ui(), diary::show_diary_ui(), auto_notes::auto_note_settings::show_gui(), show_mutations_ui(), show_scores_ui(), sleep, smash(), Character::start_destination_activity(), stats(), string_format(), game_menus::inv::swap_letters(), takeoff(), tile_iso, avatar::toggle_crouch_mode(), toggle_debug_hour_timer(), toggle_fullscreen(), avatar::toggle_map_memory(), toggle_pixel_minimap(), avatar::toggle_run_mode(), trait_PROF_CHURL, trait_SHELL2, tripoint_above, tripoint_below, try_get_left_click_action(), try_get_right_click_action(), calendar::turn, turnssincelastmon, input_event::type, u, avatar_action::unload(), uquit, avatar_action::use_item(), avatar_funcs::use_item(), use_tiles, user_action_counter, map::veh_at(), vertical_move(), player::view_offset, w_terrain, wait(), wear(), avatar_action::wield(), world_generator, point::x, tripoint::x, point::y, tripoint::y, yes, zones_manager(), zoom_in(), and zoom_out().

Referenced by do_turn().

◆ handle_key_blocking_activity()

void game::handle_key_blocking_activity ( )
private

Definition at line 1981 of file game.cpp.

1982{
1984 const std::string action = ctxt.handle_input( 0 );
1985 bool refresh = true;
1986 if( action == "pause" || action == "main_menu" ) {
1988 cancel_activity_query( _( "Confirm:" ) );
1989 }
1990 } else if( action == "player_data" ) {
1992 } else if( action == "messages" ) {
1994 } else if( action == "help" ) {
1996 } else if( action != "HELP_KEYBINDINGS" ) {
1997 refresh = false;
1998 }
1999 if( refresh ) {
2002 }
2003}
bool cancel_activity_query(const std::string &text)
Asks if the player wants to cancel their activity, and if so cancels it.
Definition: game.cpp:1765
const std::string & handle_input()
Handles input and returns the next action in the queue.
Definition: input.cpp:848
bool interruptable_with_kb
Controls whether this activity can be cancelled with 'pause' action.
void refresh()

References _, action, Character::activity, cancel_activity_query(), character_display::disp_info(), help::display_help(), Messages::display_messages(), get_default_mode_input_context(), get_help(), input_context::handle_input(), player_activity::interruptable_with_kb, ui_manager::redraw(), catacurses::refresh(), refresh_display(), and u.

Referenced by process_voluntary_act_interrupt().

◆ handle_mouseview()

bool game::handle_mouseview ( input_context ctxt,
std::string &  action 
)
private

Definition at line 2007 of file game.cpp.

2008{
2009 std::optional<tripoint> liveview_pos;
2010
2011 do {
2012 action = ctxt.handle_input();
2013 if( action == "MOUSE_MOVE" ) {
2014 const std::optional<tripoint> mouse_pos = ctxt.get_coordinates( w_terrain );
2015 if( mouse_pos && ( !liveview_pos || *mouse_pos != *liveview_pos ) ) {
2016 liveview_pos = mouse_pos;
2017 liveview.show( *liveview_pos );
2018 } else if( !mouse_pos ) {
2019 liveview_pos.reset();
2020 liveview.hide();
2021 }
2023 }
2024 } while( action == "MOUSE_MOVE" ); // Freeze animation when moving the mouse
2025
2026 if( action != "TIMEOUT" ) {
2027 // Keyboard event, break out of animation loop
2028 liveview.hide();
2029 return false;
2030 }
2031
2032 // Mouse movement or un-handled key
2033 return true;
2034}
void hide()
Definition: live_view.cpp:33
void show(const tripoint &p)
Definition: live_view.cpp:38

References action, input_context::get_coordinates(), input_context::handle_input(), live_view::hide(), liveview, ui_manager::redraw(), live_view::show(), and w_terrain.

Referenced by get_player_input().

◆ has_gametype()

bool game::has_gametype ( ) const

Definition at line 532 of file game.cpp.

533{
534 return gamemode && gamemode->id() != special_game_type::NONE;
535}

References gamemode, and NONE.

◆ init_autosave()

void game::init_autosave ( )
private

Definition at line 11276 of file game.cpp.

11277{
11279 last_save_timestamp = time( nullptr );
11280}

References last_save_timestamp, moves_since_last_save, and time.

Referenced by load(), and start_game().

◆ inv_map_splice()

item_location game::inv_map_splice ( item_filter  filter,
const std::string &  title,
int  radius = 0,
const std::string &  none_message = "" 
)

Custom-filtered menu for inventory and nearby items and those that within specified radius.

Definition at line 400 of file game_inventory.cpp.

402{
404 title, radius, none_message );
405}
static item_location_filter convert_filter(const item_filter &filter)
static item_location inv_internal(player &u, const inventory_selector_preset &preset, const std::string &title, int radius, const std::string &none_message, const std::string &hint=std::string())
std::string title(holiday current_holiday)
Definition: path_info.cpp:326

References convert_filter(), inv_internal(), PATH_INFO::title(), and u.

◆ invalidate_main_ui_adaptor()

void game::invalidate_main_ui_adaptor ( ) const

◆ is_dangerous_tile()

bool game::is_dangerous_tile ( const tripoint dest_loc) const

Definition at line 8695 of file game.cpp.

8696{
8697 return !( get_dangerous_tile( dest_loc ).empty() );
8698}
std::vector< std::string > get_dangerous_tile(const tripoint &dest_loc) const
Definition: game.cpp:8717

References get_dangerous_tile().

Referenced by walk_move().

◆ is_empty()

bool game::is_empty ( const tripoint p)

Returns true if there is no player, NPC, or monster on the tile and move_cost > 0.

Definition at line 4839 of file game.cpp.

4840{
4841 return ( m.passable( p ) || m.has_flag( "LIQUID", p ) ) &&
4842 critter_at( p ) == nullptr;
4843}

References critter_at(), map::has_flag(), m, and map::passable().

Referenced by grabbed_furn_move(), monmove(), place_player(), and update_stair_monsters().

◆ is_game_over()

bool game::is_game_over ( )
private

Definition at line 2375 of file game.cpp.

2376{
2377 if( uquit == QUIT_WATCH ) {
2378 // deny player movement and dodging
2379 u.moves = 0;
2380 // prevent pain from updating
2381 u.set_pain( 0 );
2382 // prevent dodging
2383 u.dodges_left = 0;
2384 return false;
2385 }
2386 if( uquit == QUIT_DIED ) {
2387 if( u.in_vehicle ) {
2388 m.unboard_vehicle( u.pos() );
2389 }
2390 u.place_corpse();
2391 return true;
2392 }
2393 if( uquit == QUIT_SUICIDE ) {
2394 if( u.in_vehicle ) {
2395 m.unboard_vehicle( u.pos() );
2396 }
2397 return true;
2398 }
2399 if( uquit != QUIT_NO ) {
2400 return true;
2401 }
2402 // is_dead_state() already checks hp_torso && hp_head, no need to for loop it
2403 if( u.is_dead_state() ) {
2404 if( get_option<bool>( "PROMPT_ON_CHARACTER_DEATH" ) &&
2405 !query_yn(
2406 _( "Your character is dead, do you accept this?\n\nSelect Yes to abandon the character to their fate, select No to return to main menu." ) ) ) {
2407 return true;
2408 }
2409
2411 if( get_option<std::string>( "DEATHCAM" ) == "always" ) {
2412 uquit = QUIT_WATCH;
2413 } else if( get_option<std::string>( "DEATHCAM" ) == "ask" ) {
2414 uquit = query_yn( _( "Watch the last moments of your life…?" ) ) ?
2416 } else if( get_option<std::string>( "DEATHCAM" ) == "never" ) {
2417 uquit = QUIT_DIED;
2418 } else {
2419 // Something funky happened here, just die.
2420 dbg( DL::Error ) << "no deathcam option given to options, defaulting to QUIT_DIED";
2421 uquit = QUIT_DIED;
2422 }
2423 return is_game_over();
2424 }
2425 return false;
2426}
int dodges_left
Definition: character.h:569
void set_pain(int npain) override
Sets new intensity of pain an reacts to it.
Definition: character.cpp:788
@ Error
Error (default: enabled).
#define dbg(x)
Definition: game.cpp:198
void deactivate()
Definition: messages.cpp:357

References _, dbg, Messages::deactivate(), Character::dodges_left, Error, Character::in_vehicle, Character::is_dead_state(), is_game_over(), m, Creature::moves, Character::place_corpse(), Character::pos(), query_yn(), QUIT_DIED, QUIT_NO, QUIT_SUICIDE, QUIT_WATCH, Character::set_pain(), u, map::unboard_vehicle(), and uquit.

Referenced by do_turn(), and is_game_over().

◆ is_hostile_nearby()

Creature * game::is_hostile_nearby ( )

Definition at line 3579 of file game.cpp.

3580{
3581 int distance = ( get_option<int>( "SAFEMODEPROXIMITY" ) <= 0 ) ? MAX_VIEW_DISTANCE :
3582 get_option<int>( "SAFEMODEPROXIMITY" );
3583 return is_hostile_within( distance );
3584}
Creature * is_hostile_within(int distance)
Definition: game.cpp:3591

References is_hostile_within(), and MAX_VIEW_DISTANCE.

◆ is_hostile_very_close()

Creature * game::is_hostile_very_close ( )

Definition at line 3586 of file game.cpp.

3587{
3589}
static constexpr int DANGEROUS_PROXIMITY
Definition: game.cpp:200

References DANGEROUS_PROXIMITY, and is_hostile_within().

Referenced by butcher(), and process_voluntary_act_interrupt().

◆ is_hostile_within()

Creature * game::is_hostile_within ( int  distance)
private

Definition at line 3591 of file game.cpp.

3592{
3593 for( auto &critter : u.get_visible_creatures( distance ) ) {
3594 if( u.attitude_to( *critter ) == Creature::A_HOSTILE ) {
3595 return critter;
3596 }
3597 }
3598
3599 return nullptr;
3600}
Attitude attitude_to(const Creature &other) const override
Attitude (of this creature) towards another creature.
std::vector< Creature * > get_visible_creatures(int range) const
Returns all creatures that this player can see and that are in the given range.
@ A_HOSTILE
Definition: creature.h:167

References Creature::A_HOSTILE, Character::attitude_to(), Character::get_visible_creatures(), and u.

Referenced by is_hostile_nearby(), and is_hostile_very_close().

◆ is_in_sunlight()

bool game::is_in_sunlight ( const tripoint p)

Returns true if p is outdoors and it is sunny.

Definition at line 4845 of file game.cpp.

4846{
4847 return weather::is_in_sunlight( m, p, get_weather().weather_id );
4848}
bool is_in_sunlight(const map &m, const tripoint &p, const weather_type_id &weather)
Definition: weather.cpp:1162

References get_weather, weather::is_in_sunlight(), and m.

Referenced by process_artifact().

◆ is_in_viewport()

bool game::is_in_viewport ( const tripoint p,
int  margin = 0 
) const

Definition at line 3225 of file game.cpp.

3226{
3227 const tripoint diff( u.pos() + u.view_offset - p );
3228
3229 return ( std::abs( diff.x ) <= getmaxx( w_terrain ) / 2 - margin ) &&
3230 ( std::abs( diff.y ) <= getmaxy( w_terrain ) / 2 - margin );
3231}

References catacurses::getmaxx(), catacurses::getmaxy(), Character::pos(), u, player::view_offset, w_terrain, tripoint::x, and tripoint::y.

◆ is_sheltered()

bool game::is_sheltered ( const tripoint p)

Returns true if p is indoors, underground, or in a car.

Definition at line 4850 of file game.cpp.

4851{
4852 return weather::is_sheltered( m, p );
4853}
bool is_sheltered(const map &m, const tripoint &p)
Definition: weather.cpp:1153

References weather::is_sheltered(), and m.

◆ is_zones_manager_open()

bool game::is_zones_manager_open ( ) const

Definition at line 6030 of file game.cpp.

6031{
6032 return zones_manager_open;
6033}
bool zones_manager_open
Is Zone manager open or not - changes graphics of some zone tiles.
Definition: game.h:1052

References zones_manager_open.

◆ item_action_menu()

void game::item_action_menu ( )
private

Definition at line 231 of file item_action.cpp.

232{
233 const auto &gen = item_action_generator::generator();
234 const action_map &item_actions = gen.get_item_action_map();
235
236 // HACK: A bit of a hack for now. If more pseudos get implemented, this should be un-hacked
237 std::vector<item *> pseudos;
238 item toolset( "toolset", calendar::turn );
239 if( u.has_active_bionic( bio_tools ) ) {
240 pseudos.push_back( &toolset );
241 }
242 item bio_claws_item( static_cast<std::string>( bio_claws_weapon ), calendar::turn );
243 if( u.has_active_bionic( bio_claws ) ) {
244 pseudos.push_back( &bio_claws_item );
245 }
246
247 item_action_map iactions = gen.map_actions_to_items( u, pseudos );
248 if( iactions.empty() ) {
249 popup( _( "You don't have any items with registered uses" ) );
250 }
251
252 uilist kmenu;
253 kmenu.text = _( "Execute which action?" );
254 kmenu.input_category = "ITEM_ACTIONS";
255 input_context ctxt( "ITEM_ACTIONS" );
256 for( const auto &id : item_actions ) {
257 ctxt.register_action( id.first, id.second.name );
258 kmenu.additional_actions.emplace_back( id.first, id.second.name );
259 }
260 actmenu_cb callback( item_actions );
261 kmenu.callback = &callback;
262 int num = 0;
263
264 const auto assigned_action = [&iactions]( const item_action_id & action ) {
265 return iactions.find( action ) != iactions.end();
266 };
267
268 std::vector<std::tuple<item_action_id, std::string, std::string>> menu_items;
269 // Sorts menu items by action.
270 using Iter = decltype( menu_items )::iterator;
271 const auto sort_menu = []( Iter from, Iter to ) {
272 std::sort( from, to, []( const std::tuple<item_action_id, std::string, std::string> &lhs,
273 const std::tuple<item_action_id, std::string, std::string> &rhs ) {
274 return std::get<1>( lhs ).compare( std::get<1>( rhs ) ) < 0;
275 } );
276 };
277 // Add mapped actions to the menu vector.
278 std::transform( iactions.begin(), iactions.end(), std::back_inserter( menu_items ),
279 []( const std::pair<item_action_id, item *> &elem ) {
280 std::string ss = elem.second->display_name();
281 if( elem.second->ammo_required() ) {
282 ss += string_format( " (%d/%d)", elem.second->ammo_required(), elem.second->ammo_remaining() );
283 }
284
285 const auto method = elem.second->get_use( elem.first );
286 if( method ) {
287 return std::make_tuple( method->get_type(), method->get_name(), ss );
288 } else {
289 return std::make_tuple( errstring, std::string( "NO USE FUNCTION" ), ss );
290 }
291 } );
292 // Sort mapped actions.
293 sort_menu( menu_items.begin(), menu_items.end() );
294 // Add unmapped but binded actions to the menu vector.
295 for( const auto &elem : item_actions ) {
296 if( key_bound_to( ctxt, elem.first ) != '\0' && !assigned_action( elem.first ) ) {
297 menu_items.emplace_back( elem.first, gen.get_action_name( elem.first ), "-" );
298 }
299 }
300 // Sort unmapped actions.
301 auto iter = menu_items.begin();
302 std::advance( iter, iactions.size() );
303 sort_menu( iter, menu_items.end() );
304 // Determine max lengths, to print the menu nicely.
305 std::pair<int, int> max_len;
306 for( const auto &elem : menu_items ) {
307 max_len.first = std::max( max_len.first, utf8_width( std::get<1>( elem ), true ) );
308 max_len.second = std::max( max_len.second, utf8_width( std::get<2>( elem ), true ) );
309 }
310 // Fill the menu.
311 for( const auto &elem : menu_items ) {
312 std::string ss;
313 ss += std::get<1>( elem );
314 ss += std::string( max_len.first - utf8_width( std::get<1>( elem ), true ), ' ' );
315 ss += std::string( 4, ' ' );
316
317 ss += std::get<2>( elem );
318 ss += std::string( max_len.second - utf8_width( std::get<2>( elem ), true ), ' ' );
319
320 const char bind = key_bound_to( ctxt, std::get<0>( elem ) );
321 const bool enabled = assigned_action( std::get<0>( elem ) );
322
323 kmenu.addentry( num, enabled, bind, ss );
324 num++;
325 }
326
327 kmenu.query();
328 if( kmenu.ret < 0 || kmenu.ret >= static_cast<int>( iactions.size() ) ) {
329 return;
330 }
331
332 const item_action_id action = std::get<0>( menu_items[kmenu.ret] );
333 item *it = iactions[action];
334
335 u.invoke_item( it, action );
336
337 u.inv.restack( u );
338 u.inv.unsort();
339}
inventory inv
Definition: character.h:1576
bool invoke_item(item *, const tripoint &pt) override
Asks how to use the item (if it has more than one use_method) and uses it.
Definition: avatar.cpp:1256
void restack(player &p)
Definition: inventory.cpp:399
void unsort()
Definition: inventory.cpp:227
static item_action_generator & generator()
Definition: item_action.h:32
std::string input_category
Definition: ui.h:325
std::vector< std::pair< std::string, translation > > additional_actions
Definition: ui.h:326
static char key_bound_to(const input_context &ctxt, const item_action_id &act)
Definition: item_action.cpp:47
static const bionic_id bio_claws("bio_claws")
static const bionic_id bio_tools("bio_tools")
static const bionic_id bio_claws_weapon("bio_claws_weapon")
std::string item_action_id
Definition: item_action.h:16
std::map< item_action_id, item_action > action_map
Definition: item_action.h:18
std::map< item_action_id, item * > item_action_map
Definition: item_action.h:17

References _, action, uilist::additional_actions, bio_claws, bio_claws_weapon, bio_tools, uilist::callback, item_action_generator::generator(), Character::has_active_bionic(), uilist::input_category, num, popup(), input_context::register_action(), second, uilist::text, iexamine::transform(), calendar::turn, and u.

Referenced by handle_action().

◆ knockback() [1/2]

void game::knockback ( const tripoint s,
const tripoint t,
int  force,
int  stun,
int  dam_mult,
Creature source 
)

Definition at line 4244 of file game.cpp.

4246{
4247 std::vector<tripoint> traj;
4248 traj.clear();
4249 traj = line_to( s, t, 0, 0 );
4250 traj.insert( traj.begin(), s ); // how annoying, line_to() doesn't include the originating point!
4251 traj = continue_line( traj, force );
4252 traj.insert( traj.begin(), t ); // how annoying, continue_line() doesn't either!
4253
4254 knockback( traj, stun, dam_mult, source );
4255}
std::vector< coords::coord_point< Point, Origin, Scale > > line_to(const coords::coord_point< Point, Origin, Scale > &loc1, const coords::coord_point< Point, Origin, Scale > &loc2)
Definition: coordinates.h:548
std::vector< tripoint > continue_line(const std::vector< tripoint > &line, const int distance)
Definition: line.cpp:408

References continue_line(), knockback(), and line_to().

Referenced by forced_door_closing(), and knockback().

◆ knockback() [2/2]

void game::knockback ( std::vector< tripoint > &  traj,
int  stun,
int  dam_mult,
Creature source = nullptr 
)

Definition at line 4261 of file game.cpp.

4263{
4264 // TODO: make the force parameter actually do something.
4265 // the header file says higher force causes more damage.
4266 // perhaps that is what it should do?
4267
4268 // TODO: refactor this so it's not copy/pasted 3 times
4269 tripoint tp = traj.front();
4270 if( !critter_at( tp ) ) {
4271 debugmsg( _( "Nothing at (%d,%d,%d) to knockback!" ), tp.x, tp.y, tp.z );
4272 return;
4273 }
4274 std::size_t force_remaining = traj.size();
4275 if( monster *const targ = critter_at<monster>( tp, true ) ) {
4276 tripoint start_pos = targ->pos();
4277
4278 if( stun > 0 ) {
4279 targ->add_effect( effect_stunned, 1_turns * stun );
4280 add_msg( _( "%s was stunned!" ), targ->name() );
4281 }
4282 for( size_t i = 1; i < traj.size(); i++ ) {
4283 if( m.impassable( traj[i].xy() ) || m.obstructed_by_vehicle_rotation( tp, traj[i] ) ) {
4284 targ->setpos( traj[i - 1] );
4285 force_remaining = traj.size() - i;
4286 if( stun != 0 ) {
4287 targ->add_effect( effect_stunned, 1_turns * force_remaining );
4288 add_msg( _( "%s was stunned!" ), targ->name() );
4289 add_msg( _( "%s slammed into an obstacle!" ), targ->name() );
4290 targ->apply_damage( source, bodypart_id( "torso" ), dam_mult * force_remaining );
4291 targ->check_dead_state();
4292 }
4293 m.bash( traj[i], 2 * dam_mult * force_remaining );
4294 break;
4295 } else if( critter_at( traj[i] ) ) {
4296 targ->setpos( traj[i - 1] );
4297 force_remaining = traj.size() - i;
4298 if( stun != 0 ) {
4299 targ->add_effect( effect_stunned, 1_turns * force_remaining );
4300 add_msg( _( "%s was stunned!" ), targ->name() );
4301 }
4302 traj.erase( traj.begin(), traj.begin() + i );
4303 if( critter_at<monster>( traj.front() ) ) {
4304 add_msg( _( "%s collided with something else and sent it flying!" ),
4305 targ->name() );
4306 } else if( npc *const guy = critter_at<npc>( traj.front() ) ) {
4307 if( guy->male ) {
4308 add_msg( _( "%s collided with someone else and sent him flying!" ),
4309 targ->name() );
4310 } else {
4311 add_msg( _( "%s collided with someone else and sent her flying!" ),
4312 targ->name() );
4313 }
4314 } else if( u.pos() == traj.front() ) {
4315 add_msg( m_bad, _( "%s collided with you and sent you flying!" ), targ->name() );
4316 }
4317 knockback( traj, stun, dam_mult, source );
4318 break;
4319 }
4320 targ->setpos( traj[i] );
4321 if( m.has_flag( "LIQUID", targ->pos() ) && targ->can_drown() && !targ->is_dead() ) {
4322 targ->die( source );
4323 if( u.sees( *targ ) ) {
4324 add_msg( _( "The %s drowns!" ), targ->name() );
4325 }
4326 }
4327 if( !m.has_flag( "LIQUID", targ->pos() ) && targ->has_flag( MF_AQUATIC ) &&
4328 !targ->is_dead() ) {
4329 targ->die( source );
4330 if( u.sees( *targ ) ) {
4331 add_msg( _( "The %s flops around and dies!" ), targ->name() );
4332 }
4333 }
4334 tp = traj[i];
4335 if( start_pos != targ->pos() ) {
4336 map &here = get_map();
4337 here.creature_on_trap( *targ );
4338 }
4339 }
4340 } else if( npc *const targ = critter_at<npc>( tp ) ) {
4341 tripoint start_pos = targ->pos();
4342
4343 if( stun > 0 ) {
4344 targ->add_effect( effect_stunned, 1_turns * stun );
4345 add_msg( _( "%s was stunned!" ), targ->name );
4346 }
4347 for( size_t i = 1; i < traj.size(); i++ ) {
4348 if( m.impassable( traj[i].xy() ) ||
4349 m.obstructed_by_vehicle_rotation( tp, traj[i] ) ) { // oops, we hit a wall!
4350 targ->setpos( traj[i - 1] );
4351 force_remaining = traj.size() - i;
4352 if( stun != 0 ) {
4353 targ->add_effect( effect_stunned, 1_turns * force_remaining );
4354 if( targ->has_effect( effect_stunned ) ) {
4355 add_msg( _( "%s was stunned!" ), targ->name );
4356 }
4357
4358 std::array<bodypart_id, 8> bps = {{
4359 bodypart_id( "head" ),
4360 bodypart_id( "arm_l" ), bodypart_id( "arm_r" ),
4361 bodypart_id( "hand_l" ), bodypart_id( "hand_r" ),
4362 bodypart_id( "torso" ),
4363 bodypart_id( "leg_l" ), bodypart_id( "leg_r" )
4364 }
4365 };
4366 for( const bodypart_id &bp : bps ) {
4367 if( one_in( 2 ) ) {
4368 targ->deal_damage( source, bp, damage_instance( DT_BASH, force_remaining * dam_mult ) );
4369 }
4370 }
4371 targ->check_dead_state();
4372 }
4373 m.bash( traj[i], 2 * dam_mult * force_remaining );
4374 break;
4375 } else if( critter_at( traj[i] ) ) {
4376 targ->setpos( traj[i - 1] );
4377 force_remaining = traj.size() - i;
4378 if( stun != 0 ) {
4379 add_msg( _( "%s was stunned!" ), targ->name );
4380 targ->add_effect( effect_stunned, 1_turns * force_remaining );
4381 }
4382 traj.erase( traj.begin(), traj.begin() + i );
4383 const tripoint &traj_front = traj.front();
4384 if( critter_at<monster>( traj_front ) ) {
4385 add_msg( _( "%s collided with something else and sent it flying!" ),
4386 targ->name );
4387 } else if( npc *const guy = critter_at<npc>( traj_front ) ) {
4388 if( guy->male ) {
4389 add_msg( _( "%s collided with someone else and sent him flying!" ),
4390 targ->name );
4391 } else {
4392 add_msg( _( "%s collided with someone else and sent her flying!" ),
4393 targ->name );
4394 }
4395 } else if( u.posx() == traj_front.x && u.posy() == traj_front.y &&
4397 ( u.footwear_factor() == .5 && one_in( 2 ) ) ) ) ) {
4398 add_msg( _( "%s collided with you, and barely dislodges your tentacles!" ), targ->name );
4399 } else if( u.posx() == traj_front.x && u.posy() == traj_front.y ) {
4400 add_msg( m_bad, _( "%s collided with you and sent you flying!" ), targ->name );
4401 }
4402 knockback( traj, stun, dam_mult, source );
4403 break;
4404 }
4405 targ->setpos( traj[i] );
4406 tp = traj[i];
4407
4408 if( start_pos != targ->pos() ) {
4409 map &here = get_map();
4410 here.creature_on_trap( *targ );
4411 }
4412 }
4413 } else if( u.pos() == tp ) {
4414 tripoint start_pos = u.pos();
4415
4416 if( stun > 0 ) {
4417 u.add_effect( effect_stunned, 1_turns * stun );
4418 add_msg( m_bad, vgettext( "You were stunned for %d turn!",
4419 "You were stunned for %d turns!",
4420 stun ),
4421 stun );
4422 }
4423 for( size_t i = 1; i < traj.size(); i++ ) {
4424 if( m.impassable( traj[i] ) ||
4425 m.obstructed_by_vehicle_rotation( tp, traj[i] ) ) { // oops, we hit a wall!
4426 u.setpos( traj[i - 1] );
4427 force_remaining = traj.size() - i;
4428 if( stun != 0 ) {
4429 if( u.has_effect( effect_stunned ) ) {
4430 add_msg( m_bad, vgettext( "You were stunned AGAIN for %d turn!",
4431 "You were stunned AGAIN for %d turns!",
4432 force_remaining ),
4433 force_remaining );
4434 } else {
4435 add_msg( m_bad, vgettext( "You were stunned for %d turn!",
4436 "You were stunned for %d turns!",
4437 force_remaining ),
4438 force_remaining );
4439 }
4440 u.add_effect( effect_stunned, 1_turns * force_remaining );
4441 std::array<bodypart_id, 8> bps = {{
4442 bodypart_id( "head" ),
4443 bodypart_id( "arm_l" ), bodypart_id( "arm_r" ),
4444 bodypart_id( "hand_l" ), bodypart_id( "hand_r" ),
4445 bodypart_id( "torso" ),
4446 bodypart_id( "leg_l" ), bodypart_id( "leg_r" )
4447 }
4448 };
4449 for( const bodypart_id &bp : bps ) {
4450 if( one_in( 2 ) ) {
4451 u.deal_damage( source, bp, damage_instance( DT_BASH, force_remaining * dam_mult ) );
4452 }
4453 }
4455 }
4456 m.bash( traj[i], 2 * dam_mult * force_remaining );
4457 break;
4458 } else if( critter_at( traj[i] ) ) {
4459 u.setpos( traj[i - 1] );
4460 force_remaining = traj.size() - i;
4461 if( stun != 0 ) {
4462 if( u.has_effect( effect_stunned ) ) {
4463 add_msg( m_bad, vgettext( "You were stunned AGAIN for %d turn!",
4464 "You were stunned AGAIN for %d turns!",
4465 force_remaining ),
4466 force_remaining );
4467 } else {
4468 add_msg( m_bad, vgettext( "You were stunned for %d turn!",
4469 "You were stunned for %d turns!",
4470 force_remaining ),
4471 force_remaining );
4472 }
4473 u.add_effect( effect_stunned, 1_turns * force_remaining );
4474 }
4475 traj.erase( traj.begin(), traj.begin() + i );
4476 if( critter_at<monster>( traj.front() ) ) {
4477 add_msg( _( "You collided with something and sent it flying!" ) );
4478 } else if( npc *const guy = critter_at<npc>( traj.front() ) ) {
4479 if( guy->male ) {
4480 add_msg( _( "You collided with someone and sent him flying!" ) );
4481 } else {
4482 add_msg( _( "You collided with someone and sent her flying!" ) );
4483 }
4484 }
4485 knockback( traj, stun, dam_mult, source );
4486 break;
4487 }
4488 if( m.has_flag( "LIQUID", u.pos() ) && force_remaining == 0 ) {
4489 avatar_action::swim( m, u, u.pos() );
4490 } else {
4491 u.setpos( traj[i] );
4492 }
4493 tp = traj[i];
4494
4495 if( start_pos != u.pos() ) {
4496 map &here = get_map();
4497 here.creature_on_trap( u );
4498 }
4499 }
4500 }
4501}
double footwear_factor() const
Returns 1 if the player is wearing something on both feet, .5 if on one, and 0 if on neither.
Definition: character.cpp:8917
dealt_damage_instance deal_damage(Creature *source, bodypart_id bp, const damage_instance &d) override
Calls Creature::deal_damage and handles damaged effects (waking up, etc.)
Definition: character.cpp:8445
void add_effect(const effect &eff, bool force=false, bool deferred=false)
Definition: creature.cpp:988
@ DT_BASH
Definition: damage.h:24
static const trait_id trait_LEG_TENT_BRACE("LEG_TENT_BRACE")
static const efftype_id effect_stunned("stunned")
@ MF_AQUATIC
Definition: mtype.h:89
void swim(map &m, avatar &you, const tripoint &p)
Handles swimming by the player.
const char * vgettext(const char *msgid, const char *msgid_plural, size_t n)

References _, Creature::add_effect(), add_msg(), map::bash(), Creature::check_dead_state(), map::creature_on_trap(), critter_at(), Character::deal_damage(), debugmsg, DT_BASH, effect_stunned, Character::footwear_factor(), get_map, Creature::has_effect(), map::has_flag(), Character::has_trait(), map::impassable(), knockback(), m, m_bad, MF_AQUATIC, map::obstructed_by_vehicle_rotation(), one_in(), Character::pos(), Character::posx(), Character::posy(), Character::sees(), Character::setpos(), avatar_action::swim(), trait_LEG_TENT_BRACE, u, vgettext(), tripoint::x, tripoint::y, and tripoint::z.

◆ light_level()

unsigned char game::light_level ( int  zlev) const

Returns coarse number-of-squares of visibility at the current light level.

Used by monster and NPC AI.

Definition at line 3558 of file game.cpp.

3559{
3560 const float light = natural_light_level( zlev );
3561 return LIGHT_RANGE( light );
3562}
float natural_light_level(int zlev) const
Definition: game.cpp:3498
#define LIGHT_RANGE(b)
Definition: lightmap.h:41

References light, LIGHT_RANGE, and natural_light_level().

Referenced by calc_driving_offset(), and update_overmap_seen().

◆ list_active_saves()

std::vector< std::string > game::list_active_saves ( )

Returns a list of currently active character saves.

Definition at line 2765 of file game.cpp.

2766{
2767 std::vector<std::string> saves;
2768 for( auto &worldsave : world_generator->active_world->world_saves ) {
2769 saves.push_back( worldsave.decoded_name() );
2770 }
2771 return saves;
2772}

References world_generator.

Referenced by cleanup_at_end().

◆ list_items()

game::vmenu_ret game::list_items ( const std::vector< map_item_stack > &  item_list)
private

Definition at line 7273 of file game.cpp.

7274{
7275 std::vector<map_item_stack> ground_items = item_list;
7276 int iInfoHeight = 0;
7277 int iMaxRows = 0;
7278 int width = 0;
7279 int max_name_width = 0;
7280
7281 //find max length of item name and resize window width
7282 for( const map_item_stack &cur_item : ground_items ) {
7283 const int item_len = utf8_width( remove_color_tags( cur_item.example->display_name() ) ) + 15;
7284 if( item_len > max_name_width ) {
7285 max_name_width = item_len;
7286 }
7287 }
7288
7289 tripoint active_pos;
7290 map_item_stack *activeItem = nullptr;
7291
7292 catacurses::window w_items;
7293 catacurses::window w_items_border;
7294 catacurses::window w_item_info;
7295
7296 ui_adaptor ui;
7297 ui.on_screen_resize( [&]( ui_adaptor & ui ) {
7298 iInfoHeight = std::min( 25, TERMY / 2 );
7299 iMaxRows = TERMY - iInfoHeight - 2;
7300
7301 width = clamp( max_name_width, 45, TERMX / 3 );
7302
7303 const int offsetX = TERMX - width;
7304
7305 w_items = catacurses::newwin( TERMY - 2 - iInfoHeight,
7306 width - 2, point( offsetX + 1, 1 ) );
7307 w_items_border = catacurses::newwin( TERMY - iInfoHeight,
7308 width, point( offsetX, 0 ) );
7309 w_item_info = catacurses::newwin( iInfoHeight, width,
7310 point( offsetX, TERMY - iInfoHeight ) );
7311
7312 if( activeItem ) {
7313 centerlistview( active_pos, width );
7314 }
7315
7316 ui.position( point( offsetX, 0 ), point( width, TERMY ) );
7317 } );
7318 ui.mark_resize();
7319
7320 // use previously selected sorting method
7321 bool sort_radius = uistate.list_item_sort != 2;
7322 bool addcategory = !sort_radius;
7323
7324 // reload filter/priority settings on the first invocation, if they were active
7325 if( !uistate.list_item_init ) {
7328 }
7331 }
7334 }
7335 uistate.list_item_init = true;
7336 }
7337
7338 //this stores only those items that match our filter
7339 std::vector<map_item_stack> filtered_items =
7340 !sFilter.empty() ? filter_item_stacks( ground_items, sFilter ) : ground_items;
7341 int highPEnd = list_filter_high_priority( filtered_items, list_item_upvote );
7342 int lowPStart = list_filter_low_priority( filtered_items, highPEnd, list_item_downvote );
7343 int iItemNum = ground_items.size();
7344
7345 const tripoint stored_view_offset = u.view_offset;
7346
7348
7349 int iActive = 0; // Item index that we're looking at
7350 bool refilter = true;
7351 int page_num = 0;
7352 int iCatSortNum = 0;
7353 int iScrollPos = 0;
7354 std::map<int, std::string> mSortCategory;
7355
7356 std::string action;
7357 input_context ctxt( "LIST_ITEMS" );
7358 ctxt.register_action( "UP", to_translation( "Move cursor up" ) );
7359 ctxt.register_action( "DOWN", to_translation( "Move cursor down" ) );
7360 ctxt.register_action( "LEFT", to_translation( "Previous item" ) );
7361 ctxt.register_action( "RIGHT", to_translation( "Next item" ) );
7362 ctxt.register_action( "PAGE_DOWN" );
7363 ctxt.register_action( "PAGE_UP" );
7364 ctxt.register_action( "NEXT_TAB" );
7365 ctxt.register_action( "PREV_TAB" );
7366 ctxt.register_action( "HELP_KEYBINDINGS" );
7367 ctxt.register_action( "QUIT" );
7368 ctxt.register_action( "FILTER" );
7369 ctxt.register_action( "RESET_FILTER" );
7370 ctxt.register_action( "EXAMINE" );
7371 ctxt.register_action( "COMPARE" );
7372 ctxt.register_action( "PRIORITY_INCREASE" );
7373 ctxt.register_action( "PRIORITY_DECREASE" );
7374 ctxt.register_action( "SORT" );
7375 ctxt.register_action( "TRAVEL_TO" );
7376
7377 std::optional<item_filter_type> filter_type;
7378
7379 ui.on_redraw( [&]( const ui_adaptor & ) {
7380 reset_item_list_state( w_items_border, iInfoHeight, sort_radius );
7381
7382 if( ground_items.empty() ) {
7383 wnoutrefresh( w_items_border );
7384 mvwprintz( w_items, point( 2, 10 ), c_white, _( "You don't see any items around you!" ) );
7385 } else {
7386 int iStartPos = 0;
7387 werase( w_items );
7388 calcStartPos( iStartPos, iActive, iMaxRows, iItemNum );
7389 int iNum = 0;
7390 bool high = false;
7391 bool low = false;
7392 int index = 0;
7393 int iCatSortOffset = 0;
7394
7395 for( int i = 0; i < iStartPos; i++ ) {
7396 if( !mSortCategory[i].empty() ) {
7397 iNum++;
7398 }
7399 }
7400 for( auto iter = filtered_items.begin(); iter != filtered_items.end(); ++index ) {
7401 if( highPEnd > 0 && index < highPEnd + iCatSortOffset ) {
7402 high = true;
7403 low = false;
7404 } else if( index >= lowPStart + iCatSortOffset ) {
7405 high = false;
7406 low = true;
7407 } else {
7408 high = false;
7409 low = false;
7410 }
7411
7412 if( iNum >= iStartPos && iNum < iStartPos + ( iMaxRows > iItemNum ? iItemNum : iMaxRows ) ) {
7413 int iThisPage = 0;
7414 if( !mSortCategory[iNum].empty() ) {
7415 iCatSortOffset++;
7416 mvwprintz( w_items, point( 1, iNum - iStartPos ), c_magenta, mSortCategory[iNum] );
7417 } else {
7418 if( iNum == iActive ) {
7419 iThisPage = page_num;
7420 }
7421 std::string sText;
7422 if( iter->vIG.size() > 1 ) {
7423 sText += string_format( "[%d/%d] (%d) ", iThisPage + 1, iter->vIG.size(), iter->totalcount );
7424 }
7425 sText += iter->example->tname();
7426 if( iter->vIG[iThisPage].count > 1 ) {
7427 sText += string_format( "[%d]", iter->vIG[iThisPage].count );
7428 }
7429
7430 nc_color col = c_light_green;
7431 if( iNum != iActive ) {
7432 if( high ) {
7433 col = c_yellow;
7434 } else if( low ) {
7435 col = c_red;
7436 } else {
7437 col = iter->example->color_in_inventory();
7438 }
7439 }
7440 trim_and_print( w_items, point( 1, iNum - iStartPos ), width - 9, col, sText );
7441 const int numw = iItemNum > 9 ? 2 : 1;
7442 const int x = iter->vIG[iThisPage].pos.x;
7443 const int y = iter->vIG[iThisPage].pos.y;
7444 mvwprintz( w_items, point( width - 6 - numw, iNum - iStartPos ),
7445 iNum == iActive ? c_light_green : c_light_gray,
7446 "%*d %s", numw, rl_dist( point_zero, point( x, y ) ),
7448 ++iter;
7449 }
7450 } else {
7451 ++iter;
7452 }
7453 iNum++;
7454 }
7455 iNum = 0;
7456 for( int i = 0; i < iActive; i++ ) {
7457 if( !mSortCategory[i].empty() ) {
7458 iNum++;
7459 }
7460 }
7461 mvwprintz( w_items_border, point( ( width - 9 ) / 2 + ( iItemNum > 9 ? 0 : 1 ), 0 ),
7462 c_light_green, " %*d", iItemNum > 9 ? 2 : 1, iItemNum > 0 ? iActive - iNum + 1 : 0 );
7463 wprintz( w_items_border, c_white, " / %*d ", iItemNum > 9 ? 2 : 1, iItemNum - iCatSortNum );
7464 werase( w_item_info );
7465
7466 if( iItemNum > 0 && activeItem ) {
7467 item_location loc( map_cursor( u.pos() + activeItem->example_item_pos ),
7468 const_cast<item *>( activeItem->example ) );
7470 std::vector<iteminfo> this_item = activeItem->example->info( temperature );
7471 std::vector<iteminfo> item_info_dummy;
7472
7473 item_info_data dummy( "", "", this_item, item_info_dummy, iScrollPos );
7474 dummy.without_getch = true;
7475 dummy.without_border = true;
7476
7477 draw_item_info( w_item_info, dummy );
7478 }
7479 draw_scrollbar( w_items_border, iActive, iMaxRows, iItemNum, point_south );
7480 wnoutrefresh( w_items_border );
7481 }
7482
7483 const bool bDrawLeft = ground_items.empty() || filtered_items.empty() || !activeItem || filter_type;
7484 draw_custom_border( w_item_info, bDrawLeft, true, true, true, LINE_XXXO, LINE_XOXX, true, true );
7485
7486 if( iItemNum > 0 && activeItem ) {
7487 // print info window title: < item name >
7488 mvwprintw( w_item_info, point( 2, 0 ), "< " );
7489 trim_and_print( w_item_info, point( 4, 0 ), width - 8, activeItem->example->color_in_inventory(),
7490 activeItem->example->display_name() );
7491 wprintw( w_item_info, " >" );
7492 }
7493
7494 wnoutrefresh( w_items );
7495 wnoutrefresh( w_item_info );
7496
7497 if( filter_type ) {
7498 draw_item_filter_rules( w_item_info, 0, iInfoHeight - 1, filter_type.value() );
7499 }
7500 } );
7501
7502 std::optional<tripoint> trail_start;
7503 std::optional<tripoint> trail_end;
7504 bool trail_end_x = false;
7505 shared_ptr_fast<draw_callback_t> trail_cb = create_trail_callback( trail_start, trail_end,
7506 trail_end_x );
7507 add_draw_callback( trail_cb );
7508
7509 do {
7510 if( action == "COMPARE" && activeItem ) {
7511 game_menus::inv::compare( u, active_pos );
7512 } else if( action == "FILTER" ) {
7513 filter_type = item_filter_type::FILTER;
7514 ui.invalidate_ui();
7516 .title( _( "Filter:" ) )
7517 .width( 55 )
7518 .description( _( "UP: history, CTRL-U: clear line, ESC: abort, ENTER: save" ) )
7519 .identifier( "item_filter" )
7520 .max_length( 256 )
7521 .edit( sFilter );
7522 refilter = true;
7523 addcategory = !sort_radius;
7525 filter_type = std::nullopt;
7526 } else if( action == "RESET_FILTER" ) {
7527 sFilter.clear();
7528 filtered_items = ground_items;
7529 refilter = true;
7531 addcategory = !sort_radius;
7532 } else if( action == "EXAMINE" && !filtered_items.empty() && activeItem ) {
7533 std::vector<iteminfo> dummy;
7534 const item *example_item = activeItem->example;
7535 // TODO: const_item_location
7536 item_location loc = item_location( u, const_cast<item *>( example_item ) );
7538 std::vector<iteminfo> this_item = example_item->info( temperature );
7539
7540 item_info_data info_data( example_item->tname(), example_item->type_name(), this_item, dummy );
7541 info_data.handle_scrolling = true;
7542
7544 return catacurses::newwin( TERMY, width - 5, point_zero );
7545 }, info_data );
7546 } else if( action == "PRIORITY_INCREASE" ) {
7547 filter_type = item_filter_type::HIGH_PRIORITY;
7548 ui.invalidate_ui();
7550 .title( _( "High Priority:" ) )
7551 .width( 55 )
7553 .description( _( "UP: history, CTRL-U clear line, ESC: abort, ENTER: save" ) )
7554 .identifier( "list_item_priority" )
7555 .max_length( 256 )
7556 .query_string();
7557 refilter = true;
7558 addcategory = !sort_radius;
7560 filter_type = std::nullopt;
7561 } else if( action == "PRIORITY_DECREASE" ) {
7562 filter_type = item_filter_type::LOW_PRIORITY;
7563 ui.invalidate_ui();
7565 .title( _( "Low Priority:" ) )
7566 .width( 55 )
7568 .description( _( "UP: history, CTRL-U clear line, ESC: abort, ENTER: save" ) )
7569 .identifier( "list_item_downvote" )
7570 .max_length( 256 )
7571 .query_string();
7572 refilter = true;
7573 addcategory = !sort_radius;
7575 filter_type = std::nullopt;
7576 } else if( action == "SORT" ) {
7577 if( sort_radius ) {
7578 sort_radius = false;
7579 addcategory = true;
7580 uistate.list_item_sort = 2; // list is sorted by category
7581 } else {
7582 sort_radius = true;
7583 uistate.list_item_sort = 1; // list is sorted by distance
7584 }
7585 highPEnd = -1;
7586 lowPStart = -1;
7587 iCatSortNum = 0;
7588
7589 mSortCategory.clear();
7590 refilter = true;
7591 } else if( action == "TRAVEL_TO" && activeItem ) {
7592 if( !u.sees( u.pos() + active_pos ) ) {
7593 add_msg( _( "You can't see that destination." ) );
7594 }
7595 auto route = m.route( u.pos(), u.pos() + active_pos, u.get_pathfinding_settings(),
7596 u.get_path_avoid() );
7597 if( route.size() > 1 ) {
7598 route.pop_back();
7599 u.set_destination( route );
7600 break;
7601 } else {
7602 add_msg( m_info, _( "You can't travel there." ) );
7603 }
7604 }
7605 if( uistate.list_item_sort == 1 ) {
7606 ground_items = item_list;
7607 } else if( uistate.list_item_sort == 2 ) {
7608 std::sort( ground_items.begin(), ground_items.end(), map_item_stack::map_item_stack_sort );
7609 }
7610
7611 if( refilter ) {
7612 refilter = false;
7613 filtered_items = filter_item_stacks( ground_items, sFilter );
7614 highPEnd = list_filter_high_priority( filtered_items, list_item_upvote );
7615 lowPStart = list_filter_low_priority( filtered_items, highPEnd, list_item_downvote );
7616 iActive = 0;
7617 page_num = 0;
7618 iItemNum = filtered_items.size();
7619 }
7620
7621 if( addcategory ) {
7622 addcategory = false;
7623 iCatSortNum = 0;
7624 mSortCategory.clear();
7625 if( highPEnd > 0 ) {
7626 mSortCategory[0] = _( "HIGH PRIORITY" );
7627 iCatSortNum++;
7628 }
7629 std::string last_cat_name;
7630 for( int i = std::max( 0, highPEnd );
7631 i < std::min( lowPStart, static_cast<int>( filtered_items.size() ) ); i++ ) {
7632 const std::string &cat_name = filtered_items[i].example->get_category().name();
7633 if( cat_name != last_cat_name ) {
7634 mSortCategory[i + iCatSortNum++] = cat_name;
7635 last_cat_name = cat_name;
7636 }
7637 }
7638 if( lowPStart < static_cast<int>( filtered_items.size() ) ) {
7639 mSortCategory[lowPStart + iCatSortNum++] = _( "LOW PRIORITY" );
7640 }
7641 if( !mSortCategory[0].empty() ) {
7642 iActive++;
7643 }
7644 iItemNum = static_cast<int>( filtered_items.size() ) + iCatSortNum;
7645 }
7646
7647 if( action == "UP" ) {
7648 do {
7649 iActive--;
7650
7651 } while( !mSortCategory[iActive].empty() );
7652 iScrollPos = 0;
7653 page_num = 0;
7654 if( iActive < 0 ) {
7655 iActive = iItemNum - 1;
7656 }
7657 } else if( action == "DOWN" ) {
7658 do {
7659 iActive++;
7660
7661 } while( !mSortCategory[iActive].empty() );
7662 iScrollPos = 0;
7663 page_num = 0;
7664 if( iActive >= iItemNum ) {
7665 iActive = mSortCategory[0].empty() ? 0 : 1;
7666 }
7667 } else if( action == "RIGHT" ) {
7668 if( !filtered_items.empty() && activeItem ) {
7669 if( ++page_num >= static_cast<int>( activeItem->vIG.size() ) ) {
7670 page_num = activeItem->vIG.size() - 1;
7671 }
7672 }
7673 } else if( action == "LEFT" ) {
7674 page_num = std::max( 0, page_num - 1 );
7675 } else if( action == "PAGE_UP" ) {
7676 iScrollPos--;
7677 } else if( action == "PAGE_DOWN" ) {
7678 iScrollPos++;
7679 } else if( action == "NEXT_TAB" || action == "PREV_TAB" ) {
7680 u.view_offset = stored_view_offset;
7682 }
7683
7684 active_pos = tripoint_zero;
7685 activeItem = nullptr;
7686
7687 if( mSortCategory[iActive].empty() ) {
7688 auto iter = filtered_items.begin();
7689 for( int iNum = 0; iter != filtered_items.end() && iNum < iActive; iNum++ ) {
7690 if( mSortCategory[iNum].empty() ) {
7691 ++iter;
7692 }
7693 }
7694 if( iter != filtered_items.end() ) {
7695 active_pos = iter->vIG[page_num].pos;
7696 activeItem = &( *iter );
7697 }
7698 }
7699
7700 if( activeItem ) {
7701 centerlistview( active_pos, width );
7702 trail_start = u.pos();
7703 trail_end = u.pos() + active_pos;
7704 // Actually accessed from the terrain overlay callback `trail_cb` in the
7705 // call to `ui_manager::redraw`.
7706 //NOLINTNEXTLINE(clang-analyzer-deadcode.DeadStores)
7707 trail_end_x = true;
7708 } else {
7709 u.view_offset = stored_view_offset;
7710 trail_start = trail_end = std::nullopt;
7711 }
7713
7715
7716 action = ctxt.handle_input();
7717 } while( action != "QUIT" );
7718
7719 u.view_offset = stored_view_offset;
7720 return game::vmenu_ret::QUIT;
7721}
constexpr T clamp(const T &val, const T &min, const T &max)
Clamp first argument so that it is no lower than second and no higher than third.
Definition: cata_utility.h:149
std::string list_item_upvote
Definition: game.h:1030
std::string list_item_downvote
Definition: game.h:1031
std::string sFilter
Definition: game.h:1029
void reset_item_list_state(const catacurses::window &window, int height, bool bRadiusSort)
Definition: game.cpp:7159
std::vector< iteminfo > info() const
Return all the information about the item and its type as a vector.
Definition: item.cpp:3971
nc_color color_in_inventory() const
Returns the color of the item depending on usefulness for the player character, e....
Definition: item.cpp:4127
std::string type_name(unsigned int quantity=1) const
Name of the item type (not the item), with proper plural.
Definition: item.cpp:9851
static bool map_item_stack_sort(const map_item_stack &lhs, const map_item_stack &rhs)
std::vector< item_group > vIG
const item * example
tripoint example_item_pos
string_input_popup & identifier(const std::string &value)
An identifier to be used to store / get the input history.
string_input_popup & text(const std::string &value)
Set / get the text that can be modified by the user.
void edit(std::string &value)
Edit values in place.
string_input_popup & width(int value)
Width (in console cells) of the input field itself.
string_input_popup & description(const std::string &value)
Additional help text, shown below the input box.
string_input_popup & title(const std::string &value)
The title: short string before the actual input field.
std::string list_item_priority
Definition: uistate.h:121
int list_item_sort
Definition: uistate.h:118
bool list_item_downvote_active
Definition: uistate.h:124
bool list_item_init
Definition: uistate.h:126
bool list_item_filter_active
Definition: uistate.h:123
std::string list_item_filter
Definition: uistate.h:119
bool list_item_priority_active
Definition: uistate.h:125
std::string list_item_downvote
Definition: uistate.h:120
direction direction_from(const coords::coord_point< Point, Origin, Scale > &loc1, const coords::coord_point< Point, Origin, Scale > &loc2)
Definition: coordinates.h:540
temperature_flag
Definition: enums.h:42
static shared_ptr_fast< game::draw_callback_t > create_trail_callback(const std::optional< tripoint > &trail_start, const std::optional< tripoint > &trail_end, const bool &trail_end_x)
Definition: game.cpp:3078
uistatedata uistate
Definition: game.cpp:286
static void centerlistview(const tripoint &active_item_position, int ui_width)
Definition: game.cpp:7004
std::string direction_name_short(const direction dir)
Definition: line.cpp:533
int list_filter_high_priority(std::vector< map_item_stack > &stack, const std::string &priorities)
std::vector< map_item_stack > filter_item_stacks(const std::vector< map_item_stack > &stack, const std::string &filter)
int list_filter_low_priority(std::vector< map_item_stack > &stack, const int start, const std::string &priorities)
void mvwprintw(const window &win, point p, const std::string &text)
void wprintw(const window &win, const std::string &text)
temperature_flag temperature_flag_for_location(const map &m, const item_location &loc)
Definition: rot.cpp:12
quantity< int, temperature_in_millidegree_celsius_tag > temperature
void calcStartPos(int &iStartPos, const int iCurrentLine, const int iContentHeight, const int iNumEntries)
Definition: output.cpp:1507
void draw_custom_border(const catacurses::window &w, const catacurses::chtype ls, const catacurses::chtype rs, const catacurses::chtype ts, const catacurses::chtype bs, const catacurses::chtype tl, const catacurses::chtype tr, const catacurses::chtype bl, const catacurses::chtype br, const nc_color FG, point pos, int height, int width)
Definition: output.cpp:524
void draw_item_filter_rules(const catacurses::window &win, int starty, int height, item_filter_type type)
Write some tips (such as precede items with - to exclude them) onto the window.
Definition: output.cpp:810
std::string remove_color_tags(const std::string &s)
Removes the color tags from the input string.
Definition: output.cpp:145
void trim_and_print(const catacurses::window &w, point begin, const int width, const nc_color &base_color, const std::string &text, const report_color_error color_error)
Prints a single line of text.
Definition: output.cpp:214
void draw_scrollbar(const catacurses::window &window, const int iCurrentLine, const int iContentHeight, const int iNumLines, point offset, nc_color bar_color, const bool bDoNotScrollToEnd)
Draw a scrollbar (Legacy function, use class scrollbar instead!)
Definition: output.cpp:1314
input_event draw_item_info(const int iLeft, const int iWidth, const int iTop, const int iHeight, item_info_data &data)
Definition: output.cpp:793
#define LINE_XOXX
Definition: output.h:47
#define LINE_XXXO
Definition: output.h:45

References _, action, add_draw_callback(), add_msg(), c_light_gray, c_light_green, c_magenta, c_red, c_white, c_yellow, calcStartPos(), centerlistview(), CHANGE_TAB, clamp(), item::color_in_inventory(), game_menus::inv::compare(), create_trail_callback(), string_input_popup::description(), direction_from(), direction_name_short(), item::display_name(), draw_custom_border(), draw_item_filter_rules(), draw_item_info(), draw_scrollbar(), string_input_popup::edit(), map_item_stack::example, map_item_stack::example_item_pos, FILTER, filter_item_stacks(), Character::get_path_avoid(), Character::get_pathfinding_settings(), input_context::handle_input(), item_info_data::handle_scrolling, high, HIGH_PRIORITY, string_input_popup::identifier(), item::info(), invalidate_main_ui_adaptor(), LINE_XOXX, LINE_XXXO, list_filter_high_priority(), list_filter_low_priority(), list_item_downvote, uistatedata::list_item_downvote, uistatedata::list_item_downvote_active, uistatedata::list_item_filter, uistatedata::list_item_filter_active, uistatedata::list_item_init, uistatedata::list_item_priority, uistatedata::list_item_priority_active, uistatedata::list_item_sort, list_item_upvote, LOW_PRIORITY, m, m_info, map_item_stack::map_item_stack_sort(), string_input_popup::max_length(), catacurses::mvwprintw(), mvwprintz(), catacurses::newwin(), point_south, point_zero, Character::pos(), string_input_popup::query_string(), QUIT, ui_manager::redraw(), input_context::register_action(), remove_color_tags(), reset_item_list_state(), rl_dist(), map::route(), Character::sees(), Character::set_destination(), sFilter, string_format(), rot::temperature_flag_for_location(), TERMX, TERMY, string_input_popup::text(), string_input_popup::title(), item::tname(), to_translation(), trim_and_print(), tripoint_zero, item::type_name(), u, uistate, utf8_width(), player::view_offset, map_item_stack::vIG, catacurses::werase(), string_input_popup::width(), item_info_data::without_border, item_info_data::without_getch, catacurses::wnoutrefresh(), catacurses::wprintw(), and wprintz().

Referenced by list_items_monsters().

◆ list_items_monsters()

void game::list_items_monsters ( )
private

Definition at line 7228 of file game.cpp.

7229{
7230 std::vector<Creature *> mons = u.get_visible_creatures( current_daylight_level( calendar::turn ) );
7231 // whole reality bubble
7232 const std::vector<map_item_stack> items = find_nearby_items( 60 );
7233
7234 if( mons.empty() && items.empty() ) {
7235 add_msg( m_info, _( "You don't see any items or monsters around you!" ) );
7236 return;
7237 }
7238
7239 std::sort( mons.begin(), mons.end(), [&]( const Creature * lhs, const Creature * rhs ) {
7240 const auto att_lhs = lhs->attitude_to( u );
7241 const auto att_rhs = rhs->attitude_to( u );
7242
7243 return att_lhs < att_rhs || ( att_lhs == att_rhs
7244 && rl_dist( u.pos(), lhs->pos() ) < rl_dist( u.pos(), rhs->pos() ) );
7245 } );
7246
7247 // If the current list is empty, switch to the non-empty list
7249 if( items.empty() ) {
7250 uistate.vmenu_show_items = false;
7251 }
7252 } else if( mons.empty() ) {
7254 }
7255
7258 while( true ) {
7259 ret = uistate.vmenu_show_items ? list_items( items ) : list_monsters( mons );
7262 } else {
7263 break;
7264 }
7265 }
7266
7267 if( ret == game::vmenu_ret::FIRE ) {
7269 }
7271}
double current_daylight_level(const time_point &p)
Returns the current seasonally-adjusted maximum daylight level.
Definition: calendar.cpp:171
game::vmenu_ret list_monsters(const std::vector< Creature * > &monster_list)
Definition: game.cpp:7723
game::vmenu_ret list_items(const std::vector< map_item_stack > &item_list)
Definition: game.cpp:7273
vmenu_ret
Definition: game.h:768
std::vector< map_item_stack > find_nearby_items(int iRadius)
Definition: game.cpp:6927
void temp_exit_fullscreen()
Definition: game.cpp:455
void reenter_fullscreen()
Definition: game.cpp:465
bool vmenu_show_items
Definition: uistate.h:122

References _, add_msg(), CHANGE_TAB, current_daylight_level(), find_nearby_items(), FIRE, avatar_action::fire_wielded_weapon(), Character::get_visible_creatures(), list_items(), list_monsters(), m_info, reenter_fullscreen(), cata::hash64_detail::ret, temp_exit_fullscreen(), calendar::turn, u, uistate, and uistatedata::vmenu_show_items.

Referenced by handle_action(), and look_around().

◆ list_missions()

void game::list_missions ( )

Definition at line 22 of file mission_ui.cpp.

23{
24 catacurses::window w_missions;
25
26 enum class tab_mode : int {
27 TAB_ACTIVE = 0,
28 TAB_COMPLETED,
29 TAB_FAILED,
30 NUM_TABS,
31 FIRST_TAB = 0,
32 LAST_TAB = NUM_TABS - 1
33 };
34 tab_mode tab = tab_mode::FIRST_TAB;
35 size_t selection = 0;
36 int entries_per_page = 0;
37 input_context ctxt( "MISSIONS" );
38 ctxt.register_cardinal();
39 ctxt.register_action( "CONFIRM" );
40 ctxt.register_action( "QUIT" );
41 ctxt.register_action( "HELP_KEYBINDINGS" );
42
44 ui.on_screen_resize( [&]( ui_adaptor & ui ) {
46
47 // content ranges from y=3 to FULL_SCREEN_HEIGHT - 2
48 entries_per_page = FULL_SCREEN_HEIGHT - 4;
49
50 ui.position_from_window( w_missions );
51 } );
52 ui.mark_resize();
53
54 std::vector<mission *> umissions;
55
56 ui.on_redraw( [&]( const ui_adaptor & ) {
57 werase( w_missions );
58 // entries_per_page * page number
59 const int top_of_page = entries_per_page * ( selection / entries_per_page );
60 const int bottom_of_page =
61 std::min( top_of_page + entries_per_page - 1, static_cast<int>( umissions.size() ) - 1 );
62
63 for( int i = 3; i < FULL_SCREEN_HEIGHT - 1; i++ ) {
64 mvwputch( w_missions, point( 30, i ), BORDER_COLOR, LINE_XOXO );
65 }
66
67 const std::vector<std::pair<tab_mode, std::string>> tabs = {
68 { tab_mode::TAB_ACTIVE, _( "ACTIVE MISSIONS" ) },
69 { tab_mode::TAB_COMPLETED, _( "COMPLETED MISSIONS" ) },
70 { tab_mode::TAB_FAILED, _( "FAILED MISSIONS" ) },
71 };
72 draw_tabs( w_missions, tabs, tab );
73 draw_border_below_tabs( w_missions );
74
75 mvwputch( w_missions, point( 30, 2 ), BORDER_COLOR,
76 tab == tab_mode::TAB_COMPLETED ? ' ' : LINE_OXXX ); // ^|^
77 mvwputch( w_missions, point( 30, FULL_SCREEN_HEIGHT - 1 ), BORDER_COLOR, LINE_XXOX ); // _|_
78
79 draw_scrollbar( w_missions, selection, entries_per_page, umissions.size(), point( 0, 3 ) );
80
81 for( int i = top_of_page; i <= bottom_of_page; i++ ) {
82 const auto miss = umissions[i];
83 const nc_color col = u.get_active_mission() == miss ? c_light_green : c_white;
84 const int y = i - top_of_page + 3;
85 trim_and_print( w_missions, point( 1, y ), 28,
86 static_cast<int>( selection ) == i ? hilite( col ) : col,
87 miss->name() );
88 }
89
90 if( selection < umissions.size() ) {
91 const auto miss = umissions[selection];
92 const nc_color col = u.get_active_mission() == miss ? c_light_green : c_white;
93 std::string for_npc;
94 if( miss->get_npc_id().is_valid() ) {
95 npc *guy = g->find_npc( miss->get_npc_id() );
96 if( guy ) {
97 for_npc = string_format( _( " for %s" ), guy->disp_name() );
98 }
99 }
100
101 int y = 3;
102 y += fold_and_print( w_missions, point( 31, y ), getmaxx( w_missions ) - 33, col,
103 miss->name() + for_npc );
104
105 auto format_tokenized_description = []( const std::string & description,
106 const std::vector<std::pair<int, itype_id>> &rewards ) {
107 std::string formatted_description = description;
108 for( const auto &reward : rewards ) {
109 std::string token = "<reward_count:" + reward.second.str() + ">";
110 formatted_description = replace_all( formatted_description, token,
111 string_format( "%d", reward.first ) );
112 }
113 return formatted_description;
114 };
115
116 y++;
117 if( !miss->get_description().empty() ) {
118 y += fold_and_print( w_missions, point( 31, y ), getmaxx( w_missions ) - 33, c_white,
119 format_tokenized_description( miss->get_description(), miss->get_likely_rewards() ) );
120 }
121 if( miss->has_deadline() ) {
122 const time_point deadline = miss->get_deadline();
123 mvwprintz( w_missions, point( 31, ++y ), c_white, _( "Deadline: %s" ), to_string( deadline ) );
124
125 if( tab != tab_mode::TAB_COMPLETED ) {
126 // There's no point in displaying this for a completed mission.
127 // @ TODO: But displaying when you completed it would be useful.
128 const time_duration remaining = deadline - calendar::turn;
129 std::string remaining_time;
130
131 if( remaining <= 0_turns ) {
132 remaining_time = _( "None!" );
133 } else if( u.has_watch() ) {
134 remaining_time = to_string( remaining );
135 } else {
136 remaining_time = to_string_approx( remaining );
137 }
138
139 mvwprintz( w_missions, point( 31, ++y ), c_white, _( "Time remaining: %s" ), remaining_time );
140 }
141 }
142 if( miss->has_target() ) {
144 // TODO: target does not contain a z-component, targets are assumed to be on z=0
145 mvwprintz( w_missions, point( 31, ++y ), c_white, _( "Target: %s You: %s" ),
146 miss->get_target().to_string(), pos.to_string() );
147 }
148 } else {
149 static const std::map< tab_mode, std::string > nope = {
150 { tab_mode::TAB_ACTIVE, translate_marker( "You have no active missions!" ) },
151 { tab_mode::TAB_COMPLETED, translate_marker( "You haven't completed any missions!" ) },
152 { tab_mode::TAB_FAILED, translate_marker( "You haven't failed any missions!" ) }
153 };
154 mvwprintz( w_missions, point( 31, 4 ), c_light_red, _( nope.at( tab ) ) );
155 }
156
157 wnoutrefresh( w_missions );
158 } );
159
160 while( true ) {
161 umissions.clear();
162 if( tab < tab_mode::FIRST_TAB || tab >= tab_mode::NUM_TABS ) {
163 debugmsg( "The sanity check failed because tab=%d", static_cast<int>( tab ) );
164 tab = tab_mode::FIRST_TAB;
165 }
166 switch( tab ) {
168 umissions = u.get_active_missions();
169 break;
170 case tab_mode::TAB_COMPLETED:
171 umissions = u.get_completed_missions();
172 break;
173 case tab_mode::TAB_FAILED:
174 umissions = u.get_failed_missions();
175 break;
176 default:
177 break;
178 }
179 if( ( !umissions.empty() && selection >= umissions.size() ) ||
180 ( umissions.empty() && selection != 0 ) ) {
181 debugmsg( "Sanity check failed: selection=%d, size=%d", static_cast<int>( selection ),
182 static_cast<int>( umissions.size() ) );
183 selection = 0;
184 }
186 const std::string action = ctxt.handle_input();
187 if( action == "RIGHT" ) {
188 tab = static_cast<tab_mode>( static_cast<int>( tab ) + 1 );
189 if( tab >= tab_mode::NUM_TABS ) {
190 tab = tab_mode::FIRST_TAB;
191 }
192 selection = 0;
193 } else if( action == "LEFT" ) {
194 tab = static_cast<tab_mode>( static_cast<int>( tab ) - 1 );
195 if( tab < tab_mode::FIRST_TAB ) {
196 tab = tab_mode::LAST_TAB;
197 }
198 selection = 0;
199 } else if( action == "DOWN" ) {
200 selection++;
201 if( selection >= umissions.size() ) {
202 selection = 0;
203 }
204 } else if( action == "UP" ) {
205 if( selection == 0 ) {
206 selection = umissions.empty() ? 0 : umissions.size() - 1;
207 } else {
208 selection--;
209 }
210 } else if( action == "CONFIRM" ) {
211 if( tab == tab_mode::TAB_ACTIVE && selection < umissions.size() ) {
212 u.set_active_mission( *umissions[selection] );
213 }
214 break;
215 } else if( action == "QUIT" ) {
216 break;
217 }
218 }
219}
std::string to_string_approx(const time_duration &dur, const bool verbose)
Returns approximate duration.
Definition: calendar.cpp:361
bool has_watch() const
Returns true if the player or their vehicle has a watch.
Definition: character.cpp:728
void set_active_mission(mission &cur_mission)
Set which mission is active.
Definition: avatar.cpp:214
mission * get_active_mission() const
Returns the mission that is currently active.
Definition: avatar.cpp:193
std::vector< mission * > get_completed_missions() const
Definition: avatar.cpp:183
std::vector< mission * > get_active_missions() const
Definition: avatar.cpp:178
std::vector< mission * > get_failed_missions() const
Definition: avatar.cpp:188
A point in the game time.
Definition: calendar.h:431
nc_color hilite(const nc_color &c)
Definition: color.cpp:509
void draw_tabs(const catacurses::window &w, const std::vector< std::string > &tab_texts, size_t current_tab)
Definition: output.cpp:1274
void draw_border_below_tabs(const catacurses::window &w, nc_color border_color)
Definition: output.cpp:587
int fold_and_print(const catacurses::window &w, point begin, int width, const nc_color &base_color, const std::string &text, const char split)
Fold and print text in the given window.
Definition: output.cpp:299
#define LINE_XXOX
Definition: output.h:46
#define BORDER_COLOR
Definition: output.h:92
std::string replace_all(std::string input, const std::string &what, const std::string &with)
Replace all occurences of 'what' within 'input' with 'with'.
#define translate_marker(x)
Marks a string literal to be extracted for translation.
Definition: translations.h:30
catacurses::window new_centered_win(int nlines, int ncols)
Definition: ui.cpp:30

References _, action, BORDER_COLOR, c_light_green, c_light_red, c_white, debugmsg, Character::disp_name(), draw_border_below_tabs(), draw_scrollbar(), draw_tabs(), fold_and_print(), FULL_SCREEN_HEIGHT, FULL_SCREEN_WIDTH, g, avatar::get_active_mission(), avatar::get_active_missions(), avatar::get_completed_missions(), avatar::get_failed_missions(), catacurses::getmaxx(), Character::global_omt_location(), input_context::handle_input(), Character::has_watch(), hilite(), LINE_OXXX, LINE_XOXO, LINE_XXOX, mvwprintz(), mvwputch(), new_centered_win(), ui_manager::redraw(), input_context::register_action(), input_context::register_cardinal(), replace_all(), avatar::set_active_mission(), string_format(), anonymous_namespace{bionics_ui.cpp}::TAB_ACTIVE, coords::coord_point< Point, Origin, Scale >::to_string(), to_string(), to_string_approx(), translate_marker, trim_and_print(), calendar::turn, u, catacurses::werase(), and catacurses::wnoutrefresh().

Referenced by handle_action().

◆ list_monsters()

game::vmenu_ret game::list_monsters ( const std::vector< Creature * > &  monster_list)
private

Definition at line 7723 of file game.cpp.

7724{
7725 const int iInfoHeight = 15;
7726 const int width = 45;
7727 int offsetX = 0;
7728 int iMaxRows = 0;
7729
7730 catacurses::window w_monsters;
7731 catacurses::window w_monsters_border;
7732 catacurses::window w_monster_info;
7733 catacurses::window w_monster_info_border;
7734
7735 Creature *cCurMon = nullptr;
7736 tripoint iActivePos;
7737
7738 bool hide_ui = false;
7739
7740 ui_adaptor ui;
7741 ui.on_screen_resize( [&]( ui_adaptor & ui ) {
7742 if( hide_ui ) {
7743 ui.position( point_zero, point_zero );
7744 } else {
7745 offsetX = TERMX - width;
7746 iMaxRows = TERMY - iInfoHeight - 1;
7747
7748 w_monsters = catacurses::newwin( iMaxRows, width - 2, point( offsetX + 1,
7749 1 ) );
7750 w_monsters_border = catacurses::newwin( iMaxRows + 1, width, point( offsetX,
7751 0 ) );
7752 w_monster_info = catacurses::newwin( iInfoHeight - 2, width - 2,
7753 point( offsetX + 1, TERMY - iInfoHeight + 1 ) );
7754 w_monster_info_border = catacurses::newwin( iInfoHeight, width, point( offsetX,
7755 TERMY - iInfoHeight ) );
7756
7757 if( cCurMon ) {
7758 centerlistview( iActivePos, width );
7759 }
7760
7761 ui.position( point( offsetX, 0 ), point( width, TERMY ) );
7762 }
7763 } );
7764 ui.mark_resize();
7765
7766 const int max_gun_range = u.primary_weapon().gun_range( &u );
7767
7768 const tripoint stored_view_offset = u.view_offset;
7770
7771 int iActive = 0; // monster index that we're looking at
7772
7773 std::string action;
7774 input_context ctxt( "LIST_MONSTERS" );
7775 ctxt.register_action( "UP", to_translation( "Move cursor up" ) );
7776 ctxt.register_action( "DOWN", to_translation( "Move cursor down" ) );
7777 ctxt.register_action( "NEXT_TAB" );
7778 ctxt.register_action( "PREV_TAB" );
7779 ctxt.register_action( "SAFEMODE_BLACKLIST_ADD" );
7780 ctxt.register_action( "SAFEMODE_BLACKLIST_REMOVE" );
7781 ctxt.register_action( "QUIT" );
7782 if( bVMonsterLookFire ) {
7783 ctxt.register_action( "look" );
7784 ctxt.register_action( "fire" );
7785 }
7786 ctxt.register_action( "HELP_KEYBINDINGS" );
7787
7788 // first integer is the row the attitude category string is printed in the menu
7789 std::map<int, Creature::Attitude> mSortCategory;
7790
7791 for( int i = 0, last_attitude = -1; i < static_cast<int>( monster_list.size() ); i++ ) {
7792 const auto attitude = monster_list[i]->attitude_to( u );
7793 if( attitude != last_attitude ) {
7794 mSortCategory[i + mSortCategory.size()] = attitude;
7795 last_attitude = attitude;
7796 }
7797 }
7798
7799 ui.on_redraw( [&]( const ui_adaptor & ) {
7800 if( !hide_ui ) {
7801 draw_custom_border( w_monsters_border, true, true, true, true, true, true, LINE_XOXO, LINE_XOXO );
7802 draw_custom_border( w_monster_info_border, true, true, true, true, LINE_XXXO, LINE_XOXX, true,
7803 true );
7804
7805 mvwprintz( w_monsters_border, point( 2, 0 ), c_light_green, "<Tab> " );
7806 wprintz( w_monsters_border, c_white, _( "Monsters" ) );
7807
7808 if( monster_list.empty() ) {
7809 werase( w_monsters );
7810 mvwprintz( w_monsters, point( 2, iMaxRows / 3 ), c_white,
7811 _( "You don't see any monsters around you!" ) );
7812 } else {
7813 werase( w_monsters );
7814
7815 const int iNumMonster = monster_list.size();
7816 const int iMenuSize = monster_list.size() + mSortCategory.size();
7817
7818 const int numw = iNumMonster > 999 ? 4 :
7819 iNumMonster > 99 ? 3 :
7820 iNumMonster > 9 ? 2 : 1;
7821
7822 // given the currently selected monster iActive. get the selected row
7823 int iSelPos = iActive;
7824 for( auto &ia : mSortCategory ) {
7825 int index = ia.first;
7826 if( index <= iSelPos ) {
7827 ++iSelPos;
7828 } else {
7829 break;
7830 }
7831 }
7832 int iStartPos = 0;
7833 // use selected row get the start row
7834 calcStartPos( iStartPos, iSelPos, iMaxRows - 1, iMenuSize );
7835
7836 // get first visible monster and category
7837 int iCurMon = iStartPos;
7838 auto CatSortIter = mSortCategory.cbegin();
7839 while( CatSortIter != mSortCategory.cend() && CatSortIter->first < iStartPos ) {
7840 ++CatSortIter;
7841 --iCurMon;
7842 }
7843
7844 const auto endY = std::min<int>( iMaxRows - 1, iMenuSize );
7845 for( int y = 0; y < endY; ++y ) {
7846 if( CatSortIter != mSortCategory.cend() ) {
7847 const int iCurPos = iStartPos + y;
7848 const int iCatPos = CatSortIter->first;
7849 if( iCurPos == iCatPos ) {
7850 const std::string cat_name = Creature::get_attitude_ui_data(
7851 CatSortIter->second ).first.translated();
7852 mvwprintz( w_monsters, point( 1, y ), c_magenta, cat_name );
7853 ++CatSortIter;
7854 continue;
7855 }
7856 }
7857 // select current monster
7858 const auto critter = monster_list[iCurMon];
7859 const bool selected = iCurMon == iActive;
7860 ++iCurMon;
7861 if( critter->sees( g->u ) ) {
7862 mvwprintz( w_monsters, point( 0, y ), c_yellow, "!" );
7863 }
7864 bool is_npc = false;
7865 const monster *m = dynamic_cast<monster *>( critter );
7866 const npc *p = dynamic_cast<npc *>( critter );
7867 nc_color name_color = critter->basic_symbol_color();
7868
7869 if( selected ) {
7870 name_color = hilite( name_color );
7871 }
7872
7873 if( m != nullptr ) {
7874 trim_and_print( w_monsters, point( 1, y ), width - 26, name_color, m->name() );
7875 } else {
7876 trim_and_print( w_monsters, point( 1, y ), width - 26, name_color, critter->disp_name() );
7877 is_npc = true;
7878 }
7879
7880 if( selected && !get_safemode().empty() ) {
7881 const std::string monName = is_npc ? get_safemode().npc_type_name() : m->name();
7882
7883 std::string sSafemode;
7884 if( get_safemode().has_rule( monName, Creature::A_ANY ) ) {
7885 sSafemode = _( "<R>emove from safemode Blacklist" );
7886 } else {
7887 sSafemode = _( "<A>dd to safemode Blacklist" );
7888 }
7889
7890 shortcut_print( w_monsters, point( 2, getmaxy( w_monsters ) - 1 ),
7891 c_white, c_light_green, sSafemode );
7892 }
7893
7895 std::string sText;
7896
7897 if( m != nullptr ) {
7898 m->get_HP_Bar( color, sText );
7899 } else {
7900 std::tie( sText, color ) =
7901 ::get_hp_bar( critter->get_hp(), critter->get_hp_max(), false );
7902 }
7903 mvwprintz( w_monsters, point( width - 25, y ), color, sText );
7904
7905 if( m != nullptr ) {
7906 const auto att = m->get_attitude();
7907 sText = att.first;
7908 color = att.second;
7909 } else if( p != nullptr ) {
7910 sText = npc_attitude_name( p->get_attitude() );
7911 color = p->symbol_color();
7912 }
7913 mvwprintz( w_monsters, point( width - 19, y ), color, sText );
7914
7915 const int mon_dist = rl_dist( u.pos(), critter->pos() );
7916 const int numd = mon_dist > 999 ? 4 :
7917 mon_dist > 99 ? 3 :
7918 mon_dist > 9 ? 2 : 1;
7919
7920 trim_and_print( w_monsters, point( width - ( 8 + numd ), y ), 6 + numd,
7921 selected ? c_light_green : c_light_gray,
7922 "%*d %s",
7923 numd, mon_dist,
7924 direction_name_short( direction_from( u.pos(), critter->pos() ) ) );
7925 }
7926
7927 mvwprintz( w_monsters_border, point( ( width / 2 ) - numw - 2, 0 ), c_light_green, " %*d", numw,
7928 iActive + 1 );
7929 wprintz( w_monsters_border, c_white, " / %*d ", numw, static_cast<int>( monster_list.size() ) );
7930
7931 werase( w_monster_info );
7932 if( cCurMon ) {
7933 cCurMon->print_info( w_monster_info, 1, iInfoHeight - 3, 1 );
7934 }
7935
7936 draw_custom_border( w_monster_info_border, true, true, true, true, LINE_XXXO, LINE_XOXX, true,
7937 true );
7938
7939 if( bVMonsterLookFire ) {
7940 mvwprintw( w_monster_info_border, point_east, "< " );
7941 wprintz( w_monster_info_border, c_light_green, ctxt.press_x( "look" ) );
7942 wprintz( w_monster_info_border, c_light_gray, " %s", _( "to look around" ) );
7943
7944 if( cCurMon && rl_dist( u.pos(), cCurMon->pos() ) <= max_gun_range ) {
7945 wprintw( w_monster_info_border, " " );
7946 wprintz( w_monster_info_border, c_light_green, ctxt.press_x( "fire" ) );
7947 wprintz( w_monster_info_border, c_light_gray, " %s", _( "to shoot" ) );
7948 }
7949 wprintw( w_monster_info_border, " >" );
7950 }
7951
7952 draw_scrollbar( w_monsters_border, iActive, iMaxRows, static_cast<int>( monster_list.size() ),
7953 point_south );
7954 }
7955
7956 wnoutrefresh( w_monsters_border );
7957 wnoutrefresh( w_monster_info_border );
7958 wnoutrefresh( w_monsters );
7959 wnoutrefresh( w_monster_info );
7960 }
7961 } );
7962
7963 std::optional<tripoint> trail_start;
7964 std::optional<tripoint> trail_end;
7965 bool trail_end_x = false;
7966 shared_ptr_fast<draw_callback_t> trail_cb = create_trail_callback( trail_start, trail_end,
7967 trail_end_x );
7968 add_draw_callback( trail_cb );
7969
7970 do {
7971 if( action == "UP" ) {
7972 iActive--;
7973 if( iActive < 0 ) {
7974 if( monster_list.empty() ) {
7975 iActive = 0;
7976 } else {
7977 iActive = static_cast<int>( monster_list.size() ) - 1;
7978 }
7979 }
7980 } else if( action == "DOWN" ) {
7981 iActive++;
7982 if( iActive >= static_cast<int>( monster_list.size() ) ) {
7983 iActive = 0;
7984 }
7985 } else if( action == "NEXT_TAB" || action == "PREV_TAB" ) {
7986 u.view_offset = stored_view_offset;
7988 } else if( action == "SAFEMODE_BLACKLIST_REMOVE" ) {
7989 const auto m = dynamic_cast<monster *>( cCurMon );
7990 const std::string monName = ( m != nullptr ) ? m->name() : "human";
7991
7992 if( get_safemode().has_rule( monName, Creature::A_ANY ) ) {
7994 }
7995 } else if( action == "SAFEMODE_BLACKLIST_ADD" ) {
7996 if( !get_safemode().empty() ) {
7997 const auto m = dynamic_cast<monster *>( cCurMon );
7998 const std::string monName = ( m != nullptr ) ? m->name() : "human";
7999
8000 get_safemode().add_rule( monName, Creature::A_ANY, get_option<int>( "SAFEMODEPROXIMITY" ),
8002 }
8003 } else if( action == "look" ) {
8004 hide_ui = true;
8005 ui.mark_resize();
8006 look_around();
8007 hide_ui = false;
8008 ui.mark_resize();
8009 } else if( action == "fire" ) {
8010 if( cCurMon != nullptr && rl_dist( u.pos(), cCurMon->pos() ) <= max_gun_range ) {
8011 u.last_target = shared_from( *cCurMon );
8012 add_msg( "Target_set" );
8014 u.view_offset = stored_view_offset;
8015 return game::vmenu_ret::FIRE;
8016 }
8017 }
8018
8019 if( iActive >= 0 && static_cast<size_t>( iActive ) < monster_list.size() ) {
8020 cCurMon = monster_list[iActive];
8021 iActivePos = cCurMon->pos() - u.pos();
8022 centerlistview( iActivePos, width );
8023 trail_start = u.pos();
8024 trail_end = cCurMon->pos();
8025 // Actually accessed from the terrain overlay callback `trail_cb` in the
8026 // call to `ui_manager::redraw`.
8027 //NOLINTNEXTLINE(clang-analyzer-deadcode.DeadStores)
8028 trail_end_x = false;
8029 } else {
8030 cCurMon = nullptr;
8031 iActivePos = tripoint_zero;
8032 u.view_offset = stored_view_offset;
8033 trail_start = trail_end = std::nullopt;
8034 }
8036
8038
8039 action = ctxt.handle_input();
8040 } while( action != "QUIT" );
8041
8042 u.view_offset = stored_view_offset;
8043
8044 return game::vmenu_ret::QUIT;
8045}
double recoil
Definition: character.h:571
nc_color symbol_color() const override
Definition: character.cpp:6030
static const std::pair< translation, nc_color > & get_attitude_ui_data(Attitude att)
Creature Attitude as String and color.
Definition: creature.cpp:1894
virtual const tripoint & pos() const =0
virtual int print_info(const catacurses::window &w, int vStart, int vLines, int column) const =0
Write information about this creature.
shared_ptr_fast< T > shared_from(const T &critter)
Returns a shared pointer to the given critter (which can be of any of the subclasses of Creature).
Definition: game.cpp:4583
bool bVMonsterLookFire
Definition: game.h:1034
int gun_range(const player *p) const
The weapons range in map squares.
Definition: item.cpp:7362
npc_attitude get_attitude() const
Definition: npc.cpp:3183
weak_ptr_fast< Creature > last_target
Definition: player.h:241
bool has_rule(const std::string &rule_in, Creature::Attitude attitude_in)
void remove_rule(const std::string &rule_in, Creature::Attitude attitude_in)
static nc_color color(const T_t &t)
@ RULE_BLACKLISTED
Definition: enums.h:54
constexpr double MAX_RECOIL
std::string npc_attitude_name(npc_attitude att)
Definition: npc.cpp:2584
std::pair< std::string, nc_color > get_hp_bar(const int cur_hp, const int max_hp, const bool is_mon)
Definition: output.cpp:1604
size_t shortcut_print(const catacurses::window &w, point p, nc_color text_color, nc_color shortcut_color, const std::string &fmt)
Definition: output.cpp:1543

References _, Creature::A_ANY, action, add_draw_callback(), add_msg(), safemode::add_rule(), bVMonsterLookFire, c_light_gray, c_light_green, c_magenta, c_white, c_yellow, calcStartPos(), centerlistview(), CHANGE_TAB, color(), create_trail_callback(), direction_from(), direction_name_short(), draw_custom_border(), draw_scrollbar(), FIRE, g, npc::get_attitude(), Creature::get_attitude_ui_data(), get_hp_bar(), get_safemode(), catacurses::getmaxy(), item::gun_range(), input_context::handle_input(), safemode::has_rule(), hilite(), invalidate_main_ui_adaptor(), player::last_target, LINE_XOXO, LINE_XOXX, LINE_XXXO, look_around(), m, MAX_RECOIL, catacurses::mvwprintw(), mvwprintz(), map::name(), catacurses::newwin(), npc_attitude_name(), safemode::npc_type_name(), point_east, point_south, point_zero, Creature::pos(), Character::pos(), input_context::press_x(), Character::primary_weapon(), Creature::print_info(), QUIT, Character::recoil, ui_manager::redraw(), input_context::register_action(), safemode::remove_rule(), rl_dist(), RULE_BLACKLISTED, shared_from(), shortcut_print(), Character::symbol_color(), TERMX, TERMY, to_translation(), trim_and_print(), tripoint_zero, u, player::view_offset, catacurses::werase(), catacurses::wnoutrefresh(), catacurses::wprintw(), and wprintz().

Referenced by list_items_monsters().

◆ load() [1/2]

bool game::load ( const save_t name)
private

Definition at line 2548 of file game.cpp.

2549{
2552 popup.message( "%s", _( "Please wait…\nLoading the save…" ) );
2555
2556 using namespace std::placeholders;
2557
2558 const std::string worldpath = get_world_base_save_path() + "/";
2559 const std::string playerpath = worldpath + name.base_path();
2560
2561 // Now load up the master game data; factions (and more?)
2562 load_master();
2563 u = avatar();
2564 u.set_save_id( name.decoded_name() );
2565 u.name = name.decoded_name();
2566 if( !read_from_file( playerpath + SAVE_EXTENSION, std::bind( &game::unserialize, this, _1 ) ) ) {
2567 return false;
2568 }
2569
2571 u.get_avatar_diary()->load();
2572
2574
2575 read_from_file_optional( worldpath + name.base_path() + SAVE_EXTENSION_LOG,
2576 std::bind( &memorial_logger::load, &memorial(), _1 ) );
2577
2578#if defined(__ANDROID__)
2579 read_from_file_optional( worldpath + name.base_path() + SAVE_EXTENSION_SHORTCUTS,
2580 std::bind( &game::load_shortcuts, this, _1 ) );
2581#endif
2582
2583 // Now that the player's worn items are updated, their sight limits need to be
2584 // recalculated. (This would be cleaner if u.worn were private.)
2586
2587 if( !gamemode ) {
2588 gamemode = std::make_unique<special_game>();
2589 }
2590
2591 safe_mode = get_option<bool>( "SAFEMODE" ) ? SAFE_MODE_ON : SAFE_MODE_OFF;
2592 mostseen = 0; // ...and mostseen is 0, we haven't seen any monsters yet.
2593
2594 init_autosave();
2595 get_auto_pickup().load_character(); // Load character auto pickup rules
2596 get_auto_notes_settings().load(); // Load character auto notes settings
2597 get_safemode().load_character(); // Load character safemode rules
2598 zone_manager::get_manager().load_zones(); // Load character world zones
2599 read_from_file_optional( get_world_base_save_path() + "/uistate.json", []( std::istream & stream ) {
2600 JsonIn jsin( stream );
2601 uistate.deserialize( jsin );
2602 } );
2603 reload_npcs();
2608 update_map( u );
2609 for( auto &e : u.inv_dump() ) {
2610 e->set_owner( g->u );
2611 }
2612 // legacy, needs to be here as we access the map.
2613 if( !u.getID().is_valid() ) {
2614 // player does not have a real id, so assign a new one,
2615 u.setID( assign_npc_id() );
2616 // The vehicle stores the IDs of the boarded players, so update it, too.
2617 if( u.in_vehicle ) {
2618 if( const std::optional<vpart_reference> vp = m.veh_at(
2619 u.pos() ).part_with_feature( "BOARDABLE", true ) ) {
2620 vp->part().passenger_id = u.getID();
2621 }
2622 }
2623 }
2624
2625 // populate calendar caches now, after active world is set, but before we do
2626 // anything else, to ensure they pick up the correct value from the save's
2627 // worldoptions
2628 calendar::set_eternal_season( ::get_option<bool>( "ETERNAL_SEASON" ) );
2629 calendar::set_season_length( ::get_option<int>( "SEASON_LENGTH" ) );
2630
2631 u.reset();
2632
2633 return true;
2634}
bool read_from_file(const std::string &path, const std::function< void(std::istream &)> &reader)
Try to open and read from given file using the given callback.
bool read_from_file_optional(const std::string &path, const std::function< void(std::istream &)> &reader)
void setID(character_id i, bool force=false)
Definition: character.cpp:480
std::vector< item * > inv_dump()
Definition: character.cpp:8941
void recalc_sight_limits()
Modifies the player's sight values Must be called when any of the following change: This must be call...
Definition: character.cpp:1624
void reset() override
Handles stat and bonus reset.
Definition: character.cpp:3636
Definition: json.h:172
Definition: avatar.h:55
void set_save_id(const std::string &id)
Definition: avatar.h:91
void load_map_memory()
Definition: avatar.cpp:137
Helper class that fills the background and obscures all UIs below.
Definition: ui_manager.h:193
bool is_valid() const
Definition: character_id.h:19
void load()
Definition: diary.cpp:810
void validate_linked_vehicles()
validate towed vehicles so they get linked up again after a load
Definition: game.cpp:1904
void reload_npcs()
Unloads, then loads the NPCs.
Definition: game.cpp:878
void validate_camps()
validate camps to ensure they are on the overmap list
Definition: game.cpp:1962
void load_master()
Definition: game.cpp:2517
void validate_mounted_npcs()
Definition: game.cpp:1919
character_id assign_npc_id()
Definition: game.cpp:3572
void unserialize(std::istream &fin)
Definition: savegame.cpp:167
void init_autosave()
Definition: game.cpp:11276
void validate_npc_followers()
validate list of followers to account for overmap buffers
Definition: game.cpp:1938
void load(std::istream &fin)
Loads the data in a memorial file from the given ifstream.
void load_character()
Create a popup on the UI stack that gets displayed but receives no input itself.
Definition: popup.h:278
void deserialize(const JsonObject &jo)
time_point nextweather
Definition: weather.h:205
void load_zones()
Definition: clzones.cpp:1216
static const std::string SAVE_EXTENSION(".sav")
static const std::string SAVE_EXTENSION_SHORTCUTS(".shortcuts")
static const std::string SAVE_EXTENSION_LOG(".log")
void set_season_length(int dur)
Definition: calendar.cpp:478
void set_eternal_season(bool is_eternal_season)
Definition: calendar.cpp:470

References _, assign_npc_id(), uistatedata::deserialize(), g, gamemode, get_auto_notes_settings(), get_auto_pickup(), avatar::get_avatar_diary(), zone_manager::get_manager(), get_safemode(), get_weather, get_world_base_save_path(), Character::getID(), Character::in_vehicle, init_autosave(), Character::inv_dump(), character_id::is_valid(), auto_notes::auto_note_settings::load(), diary::load(), memorial_logger::load(), auto_pickup::player_settings::load_character(), safemode::load_character(), avatar::load_map_memory(), load_master(), zone_manager::load_zones(), m, memorial(), mostseen, Character::name, om_direction::name(), weather_manager::nextweather, optional_vpart_position::part_with_feature(), popup(), Character::pos(), read_from_file(), read_from_file_optional(), Character::recalc_sight_limits(), ui_manager::redraw(), refresh_display(), reload_npcs(), Character::reset(), safe_mode, SAFE_MODE_OFF, SAFE_MODE_ON, SAVE_EXTENSION(), SAVE_EXTENSION_LOG(), SAVE_EXTENSION_SHORTCUTS(), calendar::set_eternal_season(), avatar::set_save_id(), calendar::set_season_length(), Character::setID(), calendar::turn, u, uistate, unserialize(), update_map(), validate_camps(), validate_linked_vehicles(), validate_mounted_npcs(), validate_npc_followers(), and map::veh_at().

◆ load() [2/2]

bool game::load ( const std::string &  world)

Attempt to load first valid save (if any) in world.

Definition at line 2524 of file game.cpp.

2525{
2526 world_generator->init();
2527 const WORLDPTR wptr = world_generator->get_world( world );
2528 if( !wptr ) {
2529 return false;
2530 }
2531 if( wptr->world_saves.empty() ) {
2532 debugmsg( "world '%s' contains no saves", world );
2533 return false;
2534 }
2535
2536 try {
2537 world_generator->set_active_world( wptr );
2538 g->setup();
2539 g->load( wptr->world_saves.front() );
2540 } catch( const std::exception &err ) {
2541 debugmsg( "cannot load world '%s': %s", world, err.what() );
2542 return false;
2543 }
2544
2545 return true;
2546}
std::vector< save_t > world_saves
Definition: worldfactory.h:62

References debugmsg, g, world_generator, and WORLD::world_saves.

Referenced by quickload().

◆ load_map() [1/2]

void game::load_map ( const tripoint pos_sm,
bool  pump_events = false 
)

Load the main map at given location, see map::load, in global, absolute submap coordinates.

Parameters
pump_eventsIf true, handle window events during loading. If you set this to true, do ensure that the map is not accessed before this function returns (for example, UIs that draw the map should be disabled).

Definition at line 542 of file game.cpp.

543{
544 // TODO: fix point types
545 load_map( tripoint_abs_sm( pos_sm ), pump_events );
546}
void load_map(const tripoint &pos_sm, bool pump_events=false)
Load the main map at given location, see map::load, in global, absolute submap coordinates.
Definition: game.cpp:542
coords::coord_point< tripoint, coords::origin::abs, coords::sm > tripoint_abs_sm
Definition: coordinates.h:490

References load_map().

Referenced by load_map(), place_player_overmap(), start_game(), and unserialize().

◆ load_map() [2/2]

void game::load_map ( const tripoint_abs_sm pos_sm,
bool  pump_events = false 
)

Definition at line 548 of file game.cpp.

550{
551 m.load( pos_sm, true, pump_events );
552 grid_tracker_ptr->load( m );
553}
void load(const tripoint &w, bool update_vehicles, bool pump_events=false)
Load submaps into grid.
Definition: map.cpp:6721

References grid_tracker_ptr, map::load(), and m.

◆ load_master()

void game::load_master ( )
private

Definition at line 2517 of file game.cpp.

2518{
2519 using namespace std::placeholders;
2520 const auto datafile = get_world_base_save_path() + "/" + SAVE_MASTER;
2521 read_from_file_optional( datafile, std::bind( &game::unserialize_master, this, _1 ) );
2522}
void unserialize_master(std::istream &fin)
Definition: savegame.cpp:1193
static const std::string SAVE_MASTER("master.gsav")

References get_world_base_save_path(), read_from_file_optional(), SAVE_MASTER(), and unserialize_master().

Referenced by load(), and start_game().

◆ load_npcs()

void game::load_npcs ( )

Makes any nearby NPCs on the overmap active.

Definition at line 816 of file game.cpp.

817{
818 const int radius = HALF_MAPSIZE - 1;
819 // uses submap coordinates
820 std::vector<shared_ptr_fast<npc>> just_added;
821 for( const auto &temp : overmap_buffer.get_npcs_near_player( radius ) ) {
822 const character_id &id = temp->getID();
823 const auto found = std::find_if( active_npc.begin(), active_npc.end(),
824 [id]( const shared_ptr_fast<npc> &n ) {
825 return n->getID() == id;
826 } );
827 if( found != active_npc.end() ) {
828 continue;
829 }
830 if( temp->is_active() ) {
831 continue;
832 }
833 if( temp->has_companion_mission() ) {
834 continue;
835 }
836
837 const tripoint sm_loc = temp->global_sm_location();
838 // NPCs who are out of bounds before placement would be pushed into bounds
839 // This can cause NPCs to teleport around, so we don't want that
840 if( sm_loc.x < get_levx() || sm_loc.x >= get_levx() + MAPSIZE ||
841 sm_loc.y < get_levy() || sm_loc.y >= get_levy() + MAPSIZE ||
842 ( sm_loc.z != get_levz() && !m.has_zlevels() ) ) {
843 continue;
844 }
845
846 add_msg( m_debug, "game::load_npcs: Spawning static NPC, %d:%d:%d (%d:%d:%d)",
847 get_levx(), get_levy(), get_levz(), sm_loc.x, sm_loc.y, sm_loc.z );
848 temp->place_on_map();
849 if( !m.inbounds( temp->pos() ) ) {
850 continue;
851 }
852 // In the rare case the npc was marked for death while
853 // it was on the overmap. Kill it.
854 if( temp->marked_for_death ) {
855 temp->die( nullptr );
856 } else {
857 active_npc.push_back( temp );
858 just_added.push_back( temp );
859 }
860 }
861
862 for( const auto &npc : just_added ) {
863 npc->on_load();
864 }
865
866 npcs_dirty = false;
867}
void on_load()
Retroactively update npc.
Definition: npc.cpp:2697
static constexpr int MAPSIZE

References active_npc, add_msg(), get_levx(), get_levy(), get_levz(), overmapbuffer::get_npcs_near_player(), HALF_MAPSIZE, map::has_zlevels(), map::inbounds(), m, m_debug, MAPSIZE, npcs_dirty, npc::on_load(), overmap_buffer, tripoint::x, tripoint::y, and tripoint::z.

Referenced by do_turn(), perhaps_add_random_npc(), place_player_overmap(), reload_npcs(), save_cyborg(), spawn_hallucination(), start_game(), and update_map().

◆ load_static_data()

void game::load_static_data ( )

Loads static data that does not depend on mods or similar.

Definition at line 338 of file game.cpp.

339{
340 // UI stuff, not mod-specific per definition
341 inp_mngr.init(); // Load input config JSON
342 // Init mappings for loading the json stuff
344 fullscreen = false;
345 was_fullscreen = false;
346 show_panel_adm = false;
348
349 // These functions do not load stuff from json.
350 // The content they load/initialize is hardcoded into the program.
351 // Therefore they can be loaded here.
352 // If this changes (if they load data from json), they have to
353 // be moved to game::load_mod
354
358}
static DynamicDataLoader & get_instance()
Returns the single instance of this class.
Definition: init.cpp:119
bool was_fullscreen
Definition: game.h:1016
bool fullscreen
Definition: game.h:1015
void init()
Initializes the input manager, aka loads the input mapping configuration JSON.
Definition: input.cpp:111
void init()
Definition: panels.cpp:2202
void load_global()

References fullscreen, get_auto_pickup(), get_distraction_manager(), DynamicDataLoader::get_instance(), panel_manager::get_manager(), get_safemode(), input_manager::init(), panel_manager::init(), inp_mngr, distraction_manager::distraction_manager_gui::load(), auto_pickup::player_settings::load_global(), safemode::load_global(), show_panel_adm, and was_fullscreen.

◆ look_around() [1/2]

std::optional< tripoint > game::look_around ( bool  force_3d = false)

Definition at line 6575 of file game.cpp.

6576{
6578 look_around_result result = look_around( /*show_window=*/true, center, center, false, false,
6579 false, false, tripoint_zero, force_3d );
6580 return result.position;
6581}

References center, look_around(), Character::pos(), tripoint_zero, u, and player::view_offset.

Referenced by chat(), handle_action(), list_monsters(), look_around(), peek(), and zones_manager().

◆ look_around() [2/2]

look_around_result game::look_around ( bool  show_window,
tripoint center,
const tripoint start_point,
bool  has_first_point,
bool  select_zone,
bool  peeking,
bool  is_moving_zone = false,
const tripoint end_point = tripoint_zero,
bool  force_3d = false 
)
Parameters
show_windowdisplay the info window that holds the tile information in the position.
centerused to calculate the u.view_offset, could center the screen to the position it represents
start_pointthe start point of the targeting zone, also the initial local position of the cursor
has_first_pointshould be true if the first point has been selected when editing the zone
select_zonetrue if the zone is being edited
peekingdetermines if the player is peeking
is_moving_zonetrue if the zone is being moved, false by default
end_pointthe end point of the targeting zone, only used if is_moving_zone is true, default is tripoint_zero
Returns
look_around_result

Definition at line 6583 of file game.cpp.

6586{
6587 bVMonsterLookFire = false;
6588 // TODO: Make this `true`
6589 const bool allow_zlev_move = m.has_zlevels() && ( get_option<bool>( "FOV_3D" ) || force_3d );
6590
6592
6593 tripoint lp = is_moving_zone ? ( start_point + end_point ) / 2 : start_point; // cursor
6594 int &lx = lp.x;
6595 int &ly = lp.y;
6596 int &lz = lp.z;
6597
6598 int soffset = get_option<int>( "FAST_SCROLL_OFFSET" );
6599 bool fast_scroll = false;
6600
6601 std::unique_ptr<ui_adaptor> ui;
6602 catacurses::window w_info;
6603 if( show_window ) {
6604 ui = std::make_unique<ui_adaptor>();
6605 ui->on_screen_resize( [&]( ui_adaptor & ui ) {
6606 int panel_width = panel_manager::get_manager().get_current_layout().begin()->get_width();
6608
6609 // If particularly small, base height on panel width irrespective of other elements.
6610 // Value here is attempting to get a square-ish result assuming 1x2 proportioned font.
6611 if( height < panel_width / 2 ) {
6612 height = panel_width / 2;
6613 }
6614
6615 int la_y = 0;
6616 int la_x = TERMX - panel_width;
6617 std::string position = get_option<std::string>( "LOOKAROUND_POSITION" );
6618 if( position == "left" ) {
6619 if( get_option<std::string>( "SIDEBAR_POSITION" ) == "right" ) {
6621 } else {
6622 la_x = panel_manager::get_manager().get_width_left() - panel_width;
6623 }
6624 }
6625 int la_h = height;
6626 int la_w = panel_width;
6627 w_info = catacurses::newwin( la_h, la_w, point( la_x, la_y ) );
6628
6629 ui.position_from_window( w_info );
6630 } );
6631 ui->mark_resize();
6632 }
6633
6634 std::string action;
6635 input_context ctxt( "LOOK" );
6636 ctxt.set_iso( true );
6637 ctxt.register_directions();
6638 ctxt.register_action( "COORDINATE" );
6639 ctxt.register_action( "LEVEL_UP" );
6640 ctxt.register_action( "LEVEL_DOWN" );
6641 ctxt.register_action( "TOGGLE_FAST_SCROLL" );
6642 ctxt.register_action( "EXTENDED_DESCRIPTION" );
6643 ctxt.register_action( "SELECT" );
6644 if( peeking ) {
6645 ctxt.register_action( "throw_blind" );
6646 }
6647 if( !select_zone ) {
6648 ctxt.register_action( "TRAVEL_TO" );
6649 ctxt.register_action( "LIST_ITEMS" );
6650 }
6651 ctxt.register_action( "MOUSE_MOVE" );
6652 ctxt.register_action( "CENTER" );
6653
6654 ctxt.register_action( "debug_scent" );
6655 ctxt.register_action( "debug_scent_type" );
6656 ctxt.register_action( "debug_temp" );
6657 ctxt.register_action( "debug_visibility" );
6658 ctxt.register_action( "debug_lighting" );
6659 ctxt.register_action( "debug_radiation" );
6660 ctxt.register_action( "debug_submap_grid" );
6661 ctxt.register_action( "debug_hour_timer" );
6662 ctxt.register_action( "CONFIRM" );
6663 ctxt.register_action( "QUIT" );
6664 ctxt.register_action( "HELP_KEYBINDINGS" );
6665 if( use_tiles ) {
6666 ctxt.register_action( "zoom_out" );
6667 ctxt.register_action( "zoom_in" );
6668 }
6669#if defined(TILES)
6670 ctxt.register_action( "toggle_pixel_minimap" );
6671#endif // TILES
6672
6673 const int old_levz = get_levz();
6674 const int min_levz = force_3d ? -OVERMAP_DEPTH : std::max( old_levz - fov_3d_z_range,
6675 -OVERMAP_DEPTH );
6676 const int max_levz = force_3d ? OVERMAP_HEIGHT : std::min( old_levz + fov_3d_z_range,
6678
6679 m.update_visibility_cache( old_levz );
6681
6682 bool blink = true;
6684
6685 shared_ptr_fast<draw_callback_t> ter_indicator_cb;
6686
6687 if( show_window && ui ) {
6688 ui->on_redraw( [&]( const ui_adaptor & ) {
6689 werase( w_info );
6690 draw_border( w_info );
6691
6692 center_print( w_info, 0, c_white, string_format( _( "< <color_green>Look Around</color> >" ) ) );
6693
6694 std::string extended_descr_text = string_format( _( "%s - %s" ),
6695 ctxt.get_desc( "EXTENDED_DESCRIPTION" ),
6696 ctxt.get_action_name( "EXTENDED_DESCRIPTION" ) );
6697 std::string fast_scroll_text = string_format( _( "%s - %s" ),
6698 ctxt.get_desc( "TOGGLE_FAST_SCROLL" ),
6699 ctxt.get_action_name( "TOGGLE_FAST_SCROLL" ) );
6700#if defined(TILES)
6701 std::string pixel_minimap_text = string_format( _( "%s - %s" ),
6702 ctxt.get_desc( "toggle_pixel_minimap" ),
6703 ctxt.get_action_name( "toggle_pixel_minimap" ) );
6704#endif // TILES
6705
6706 center_print( w_info, getmaxy( w_info ) - 2, c_light_gray, extended_descr_text );
6707 mvwprintz( w_info, point( 1, getmaxy( w_info ) - 1 ), fast_scroll ? c_light_green : c_green,
6708 fast_scroll_text );
6709#if defined(TILES)
6710 right_print( w_info, getmaxy( w_info ) - 1, 1, pixel_minimap_option ? c_light_green : c_green,
6711 pixel_minimap_text );
6712#endif // TILES
6713
6714 int first_line = 1;
6715 const int last_line = getmaxy( w_info ) - 3;
6716 pre_print_all_tile_info( lp, w_info, first_line, last_line, cache );
6717
6718 wnoutrefresh( w_info );
6719 } );
6720 ter_indicator_cb = make_shared_fast<draw_callback_t>( [&]() {
6721 draw_look_around_cursor( lp, cache );
6722 } );
6723 add_draw_callback( ter_indicator_cb );
6724 }
6725
6726 std::optional<tripoint> zone_start;
6727 std::optional<tripoint> zone_end;
6728 bool zone_blink = false;
6729 bool zone_cursor = true;
6730 shared_ptr_fast<draw_callback_t> zone_cb = create_zone_callback( zone_start, zone_end, zone_blink,
6731 zone_cursor, is_moving_zone );
6732 add_draw_callback( zone_cb );
6733
6734 is_looking = true;
6735 const tripoint prev_offset = u.view_offset;
6736#if defined(TILES)
6737 const int prev_tileset_zoom = tileset_zoom;
6738 while( is_moving_zone && square_dist( start_point, end_point ) > 256 / get_zoom() &&
6739 get_zoom() != 4 ) {
6740 zoom_out();
6741 }
6743#endif
6744 do {
6745 u.view_offset = center - u.pos();
6746 if( select_zone ) {
6747 if( has_first_point ) {
6748 zone_start = start_point;
6749 zone_end = lp;
6750 } else {
6751 zone_start = lp;
6752 zone_end = std::nullopt;
6753 }
6754 // Actually accessed from the terrain overlay callback `zone_cb` in the
6755 // call to `ui_manager::redraw`.
6756 //NOLINTNEXTLINE(clang-analyzer-deadcode.DeadStores)
6757 zone_blink = blink;
6758 }
6759
6760 if( is_moving_zone ) {
6761 zone_start = lp - ( start_point + end_point ) / 2 + start_point;
6762 zone_end = lp - ( start_point + end_point ) / 2 + end_point;
6763 // Actually accessed from the terrain overlay callback `zone_cb` in the
6764 // call to `ui_manager::redraw`.
6765 //NOLINTNEXTLINE(clang-analyzer-deadcode.DeadStores)
6766 zone_blink = blink;
6767 }
6770 if( ( select_zone && has_first_point ) || is_moving_zone ) {
6771 ctxt.set_timeout( get_option<int>( "BLINK_SPEED" ) );
6772 }
6773
6774 //Wait for input
6775 // only specify a timeout here if "EDGE_SCROLL" is enabled
6776 // otherwise use the previously set timeout
6777 const tripoint edge_scroll = mouse_edge_scrolling_terrain( ctxt );
6778 const int scroll_timeout = get_option<int>( "EDGE_SCROLL" );
6779 const bool edge_scrolling = edge_scroll != tripoint_zero && scroll_timeout >= 0;
6780 if( edge_scrolling ) {
6781 action = ctxt.handle_input( scroll_timeout );
6782 } else {
6783 action = ctxt.handle_input();
6784 }
6785 if( ( action == "LEVEL_UP" || action == "LEVEL_DOWN" || action == "MOUSE_MOVE" ||
6786 ctxt.get_direction( action ) ) && ( ( select_zone && has_first_point ) || is_moving_zone ) ) {
6787 blink = true; // Always draw blink symbols when moving cursor
6788 } else if( action == "TIMEOUT" ) {
6789 blink = !blink;
6790 }
6791 if( action == "LIST_ITEMS" ) {
6793 } else if( action == "TOGGLE_FAST_SCROLL" ) {
6794 fast_scroll = !fast_scroll;
6795 } else if( action == "toggle_pixel_minimap" ) {
6797
6798 if( show_window && ui ) {
6799 ui->mark_resize();
6800 }
6801 } else if( action == "LEVEL_UP" || action == "LEVEL_DOWN" ) {
6802 if( !allow_zlev_move ) {
6803 continue;
6804 }
6805
6806 const int dz = ( action == "LEVEL_UP" ? 1 : -1 );
6807 lz = clamp( lz + dz, min_levz, max_levz );
6808 center.z = clamp( center.z + dz, min_levz, max_levz );
6809
6810 add_msg( m_debug, "levx: %d, levy: %d, levz: %d", get_levx(), get_levy(), center.z );
6811 u.view_offset.z = center.z - u.posz();
6813 } else if( action == "TRAVEL_TO" ) {
6814 if( !u.sees( lp ) ) {
6815 add_msg( _( "You can't see that destination." ) );
6816 continue;
6817 }
6818
6819 auto route = m.route( u.pos(), lp, u.get_pathfinding_settings(), u.get_path_avoid() );
6820 if( route.size() > 1 ) {
6821 route.pop_back();
6822 u.set_destination( route );
6823 } else {
6824 add_msg( m_info, _( "You can't travel there." ) );
6825 continue;
6826 }
6827 } else if( action == "debug_scent" || action == "debug_scent_type" ) {
6829 display_scent();
6830 }
6831 } else if( action == "debug_temp" ) {
6834 }
6835 } else if( action == "debug_lighting" ) {
6838 }
6839 } else if( action == "debug_transparency" ) {
6842 }
6843 } else if( action == "debug_radiation" ) {
6846 }
6847 } else if( action == "debug_submap_grid" ) {
6848 g->debug_submap_grid_overlay = !g->debug_submap_grid_overlay;
6849 } else if( action == "debug_hour_timer" ) {
6851 } else if( action == "EXTENDED_DESCRIPTION" ) {
6853 } else if( action == "CENTER" ) {
6854 center = u.pos();
6855 lp = u.pos();
6856 u.view_offset.z = 0;
6857 } else if( action == "MOUSE_MOVE" || action == "TIMEOUT" ) {
6858 // This block is structured this way so that edge scroll can work
6859 // whether the mouse is moving at the edge or simply stationary
6860 // at the edge. But even if edge scroll isn't in play, there's
6861 // other things for us to do here.
6862
6863 if( edge_scrolling ) {
6864 center += action == "MOUSE_MOVE" ? edge_scroll * 2 : edge_scroll;
6865 } else if( action == "MOUSE_MOVE" ) {
6866 const std::optional<tripoint> mouse_pos = ctxt.get_coordinates( w_terrain );
6867 if( mouse_pos ) {
6868 lx = mouse_pos->x;
6869 ly = mouse_pos->y;
6870 }
6871 }
6872 } else if( std::optional<tripoint> vec = ctxt.get_direction( action ) ) {
6873 if( fast_scroll ) {
6874 vec->x *= soffset;
6875 vec->y *= soffset;
6876 }
6877
6878 lx = lx + vec->x;
6879 ly = ly + vec->y;
6880 center.x = center.x + vec->x;
6881 center.y = center.y + vec->y;
6882 } else if( action == "throw_blind" ) {
6883 result.peek_action = PA_BLIND_THROW;
6884 } else if( action == "zoom_in" ) {
6885 center.x = lp.x;
6886 center.y = lp.y;
6887 zoom_in();
6889 } else if( action == "zoom_out" ) {
6890 center.x = lp.x;
6891 center.y = lp.y;
6892 zoom_out();
6894 }
6895 } while( action != "QUIT" && action != "CONFIRM" && action != "SELECT" && action != "TRAVEL_TO" &&
6896 action != "throw_blind" );
6897
6898 if( m.has_zlevels() && center.z != old_levz ) {
6899 m.invalidate_map_cache( old_levz );
6900 m.build_map_cache( old_levz );
6901 u.view_offset.z = 0;
6902 }
6903
6904 ctxt.reset_timeout();
6905 u.view_offset = prev_offset;
6906 zone_cb = nullptr;
6907 is_looking = false;
6908
6910 bVMonsterLookFire = true;
6911
6912 if( action == "CONFIRM" || action == "SELECT" ) {
6913 result.position = is_moving_zone ? zone_start : lp;
6914 }
6915
6916#if defined(TILES)
6917 if( is_moving_zone && get_zoom() != prev_tileset_zoom ) {
6918 // Reset the tileset zoom to the previous value
6919 set_zoom( prev_tileset_zoom );
6921 }
6922#endif
6923
6924 return result;
6925}
bool pixel_minimap_option
Whether to show the pixel minimap.
tripoint mouse_edge_scrolling_terrain(input_context &ctxt)
Used to implement mouse "edge scrolling".
Definition: game.cpp:2089
void set_zoom(int level)
Definition: game.cpp:7082
void draw_look_around_cursor(const tripoint &lp, const visibility_variables &cache)
Definition: game.cpp:5683
void extended_description(const tripoint &p)
Long description of (visible) things at tile.
void pre_print_all_tile_info(const tripoint &lp, const catacurses::window &w_info, int &line, int last_line, const visibility_variables &cache)
Definition: game.cpp:6562
int get_zoom() const
Definition: game.cpp:7094
const visibility_variables & get_visibility_variables_cache() const
Definition: map.cpp:5756
void invalidate_map_cache(const int zlev)
Definition: map.cpp:8941
std::vector< window_panel > & get_current_layout()
Definition: panels.cpp:2170
int square_dist(const coords::coord_point< Point, Origin, Scale > &loc1, const coords::coord_point< Point, Origin, Scale > &loc2)
Definition: coordinates.h:505
static shared_ptr_fast< game::draw_callback_t > create_zone_callback(const std::optional< tripoint > &zone_start, const std::optional< tripoint > &zone_end, const bool &zone_blink, const bool &zone_cursor, const bool &is_moving_zone=false)
Definition: game.cpp:3031
@ PA_BLIND_THROW
Definition: game.h:122
static constexpr int OVERMAP_HEIGHT
static constexpr int OVERMAP_DEPTH
int right_print(const catacurses::window &w, const int line, const int right_indent, const nc_color &FG, const std::string &text)
Definition: output.cpp:461

References _, action, add_draw_callback(), add_msg(), map::build_map_cache(), bVMonsterLookFire, c_green, c_light_gray, c_light_green, c_white, center, center_print(), clamp(), create_zone_callback(), display_lighting(), display_radiation(), display_scent(), display_temperature(), display_transparency(), draw_border(), draw_look_around_cursor(), extended_description(), fov_3d_z_range, g, input_context::get_action_name(), input_context::get_coordinates(), panel_manager::get_current_layout(), input_context::get_desc(), input_context::get_direction(), get_levx(), get_levy(), get_levz(), panel_manager::get_manager(), Character::get_path_avoid(), Character::get_pathfinding_settings(), map::get_visibility_variables_cache(), panel_manager::get_width_left(), get_zoom(), catacurses::getmaxy(), input_context::handle_input(), map::has_zlevels(), invalidate_main_ui_adaptor(), map::invalidate_map_cache(), is_looking, MAP_SHARING::isCompetitive(), MAP_SHARING::isDebugger(), list_items_monsters(), m, m_debug, m_info, mark_main_ui_adaptor_resize(), mouse_edge_scrolling_terrain(), mvwprintz(), catacurses::newwin(), OVERMAP_DEPTH, OVERMAP_HEIGHT, PA_BLIND_THROW, pixel_minimap_option, Character::pos(), Character::posz(), pre_print_all_tile_info(), ui_manager::redraw(), reenter_fullscreen(), input_context::register_action(), input_context::register_directions(), input_context::reset_timeout(), right_print(), map::route(), Character::sees(), Character::set_destination(), input_context::set_iso(), input_context::set_timeout(), set_zoom(), square_dist(), string_format(), temp_exit_fullscreen(), TERMX, TERMY, tileset_zoom, toggle_debug_hour_timer(), toggle_pixel_minimap(), tripoint_zero, u, map::update_visibility_cache(), use_tiles, player::view_offset, w_pixel_minimap, w_terrain, catacurses::werase(), catacurses::wnoutrefresh(), tripoint::x, tripoint::y, tripoint::z, zoom_in(), and zoom_out().

◆ look_debug()

std::optional< tripoint > game::look_debug ( )

Definition at line 5676 of file game.cpp.

5677{
5678 editmap edit;
5679 return edit.edit();
5680}
std::optional< tripoint > edit()
Definition: editmap.cpp:340

References editmap::edit().

◆ mark_main_ui_adaptor_resize()

void game::mark_main_ui_adaptor_resize ( ) const

Definition at line 2988 of file game.cpp.

2989{
2991 if( ui ) {
2992 ui->mark_resize();
2993 }
2994}

References main_ui_adaptor.

Referenced by handle_action(), look_around(), toggle_fullscreen(), and toggle_pixel_minimap().

◆ memorial()

memorial_logger & game::memorial ( )

Definition at line 2727 of file game.cpp.

2728{
2729 return *memorial_logger_ptr;
2730}

References memorial_logger_ptr.

Referenced by cleanup_at_end(), load(), save_player_data(), win(), win_screen(), and write_memorial_file().

◆ mon_info()

void game::mon_info ( const catacurses::window w,
int  hor_padding = 0 
)

Definition at line 3679 of file game.cpp.

3680{
3681 const monster_visible_info &mon_visible = u.get_mon_visible();
3682 const auto &unique_types = mon_visible.unique_types;
3683 const auto &unique_mons = mon_visible.unique_mons;
3684 const auto &dangerous = mon_visible.dangerous;
3685
3686 const int width = getmaxx( w ) - 2 * hor_padding;
3687 const int maxheight = getmaxy( w );
3688
3689 const int startrow = 0;
3690
3691 // Print the direction headings
3692 // Reminder:
3693 // 7 0 1 unique_types uses these indices;
3694 // 6 8 2 0-7 are provide by direction_from()
3695 // 5 4 3 8 is used for local monsters (for when we explain them below)
3696
3697 const std::array<std::string, 8> dir_labels = {{
3698 _( "North:" ), _( "NE:" ), _( "East:" ), _( "SE:" ),
3699 _( "South:" ), _( "SW:" ), _( "West:" ), _( "NW:" )
3700 }
3701 };
3702 std::array<int, 8> widths;
3703 for( int i = 0; i < 8; i++ ) {
3704 widths[i] = utf8_width( dir_labels[i] );
3705 }
3706 std::array<int, 8> xcoords;
3707 const std::array<int, 8> ycoords = {{ 0, 0, 1, 2, 2, 2, 1, 0 }};
3708 xcoords[0] = xcoords[4] = width / 3;
3709 xcoords[1] = xcoords[3] = xcoords[2] = ( width / 3 ) * 2;
3710 xcoords[5] = xcoords[6] = xcoords[7] = 0;
3711 //for the alignment of the 1,2,3 rows on the right edge
3712 xcoords[2] -= utf8_width( _( "East:" ) ) - utf8_width( _( "NE:" ) );
3713 for( int i = 0; i < 8; i++ ) {
3714 nc_color c = unique_types[i].empty() && unique_mons[i].empty() ? c_dark_gray
3715 : ( dangerous[i] ? c_light_red : c_light_gray );
3716 mvwprintz( w, point( xcoords[i] + hor_padding, ycoords[i] + startrow ), c, dir_labels[i] );
3717 }
3718
3719 // Print the symbols of all monsters in all directions.
3720 for( int i = 0; i < 8; i++ ) {
3721 point pr( xcoords[i] + widths[i] + 1, ycoords[i] + startrow );
3722
3723 // The list of symbols needs a space on each end.
3724 int symroom = ( width / 3 ) - widths[i] - 2;
3725 const int typeshere_npc = unique_types[i].size();
3726 const int typeshere_mon = unique_mons[i].size();
3727 const int typeshere = typeshere_mon + typeshere_npc;
3728 for( int j = 0; j < typeshere && j < symroom; j++ ) {
3729 nc_color c;
3730 std::string sym;
3731 if( symroom < typeshere && j == symroom - 1 ) {
3732 // We've run out of room!
3733 c = c_white;
3734 sym = "+";
3735 } else if( j < typeshere_npc ) {
3736 switch( unique_types[i][j]->get_attitude() ) {
3737 case NPCATT_KILL:
3738 c = c_red;
3739 break;
3740 case NPCATT_FOLLOW:
3741 c = c_light_green;
3742 break;
3743 default:
3744 c = c_pink;
3745 break;
3746 }
3747 sym = "@";
3748 } else {
3749 const mtype &mt = *unique_mons[i][j - typeshere_npc].first;
3750 c = mt.color;
3751 sym = mt.sym;
3752 }
3753 mvwprintz( w, pr, c, sym );
3754
3755 pr.x++;
3756 }
3757 }
3758
3759 // Now we print their full names!
3760 struct nearest_loc_and_cnt {
3761 int nearest_loc;
3762 int cnt;
3763 };
3764 std::map<const mtype *, nearest_loc_and_cnt> all_mons;
3765 for( int loc = 0; loc < 9; loc++ ) {
3766 for( const std::pair<const mtype *, int> &mon : unique_mons[loc] ) {
3767 const auto mon_it = all_mons.find( mon.first );
3768 if( mon_it == all_mons.end() ) {
3769 all_mons.emplace( mon.first, nearest_loc_and_cnt{ loc, mon.second } );
3770 } else {
3771 // 8 being the nearest location (local monsters)
3772 mon_it->second.nearest_loc = std::max( mon_it->second.nearest_loc, loc );
3773 mon_it->second.cnt += mon.second;
3774 }
3775 }
3776 }
3777 std::vector<std::pair<const mtype *, int>> mons_at[9];
3778 for( const std::pair<const mtype *const, nearest_loc_and_cnt> &mon : all_mons ) {
3779 mons_at[mon.second.nearest_loc].emplace_back( mon.first, mon.second.cnt );
3780 }
3781
3782 // Start printing monster names on row 4. Rows 0-2 are for labels, and row 3
3783 // is blank.
3784 point pr( hor_padding, 4 + startrow );
3785
3786 // Print monster names, starting with those at location 8 (nearby).
3787 for( int j = 8; j >= 0 && pr.y < maxheight; j-- ) {
3788 // Separate names by some number of spaces (more for local monsters).
3789 int namesep = ( j == 8 ? 2 : 1 );
3790 for( const std::pair<const mtype *, int> &mon : mons_at[j] ) {
3791 const mtype *const type = mon.first;
3792 const int count = mon.second;
3793 if( pr.y >= maxheight ) {
3794 // no space to print to anyway
3795 break;
3796 }
3797
3798 const mtype &mt = *type;
3799 std::string name = mt.nname( count );
3800 // Some languages don't have plural forms, but we want to always
3801 // omit 1.
3802 if( count != 1 ) {
3803 name = string_format( pgettext( "monster count and name", "%1$d %2$s" ),
3804 count, name );
3805 }
3806
3807 // Move to the next row if necessary. (The +2 is for the "Z ").
3808 if( pr.x + 2 + utf8_width( name ) >= width ) {
3809 pr.y++;
3810 pr.x = hor_padding;
3811 }
3812
3813 if( pr.y < maxheight ) { // Don't print if we've overflowed
3814 mvwprintz( w, pr, mt.color, mt.sym );
3815 pr.x += 2; // symbol and space
3816 nc_color danger = c_dark_gray;
3817 if( mt.difficulty >= 30 ) {
3818 danger = c_red;
3819 } else if( mt.difficulty >= 16 ) {
3820 danger = c_light_red;
3821 } else if( mt.difficulty >= 8 ) {
3822 danger = c_white;
3823 } else if( mt.agro > 0 ) {
3824 danger = c_light_gray;
3825 }
3826 mvwprintz( w, pr, danger, name );
3827 pr.x += utf8_width( name ) + namesep;
3828 }
3829 }
3830 }
3831}
@ NPCATT_KILL
Definition: npc.h:91
@ NPCATT_FOLLOW
Definition: npc.h:84
std::vector< std::pair< const mtype *, int > > unique_mons[9]
Definition: avatar.h:48
bool dangerous[8]
Definition: avatar.h:51
std::vector< npc * > unique_types[9]
Definition: avatar.h:47
Definition: mtype.h:208
std::string sym
UTF-8 encoded symbol, should be exactly one cell wide.
Definition: mtype.h:256
nc_color color
Definition: mtype.h:261
int difficulty
Definition: mtype.h:267
int agro
e.g.
Definition: mtype.h:272

References _, mtype::agro, c, c_dark_gray, c_light_gray, c_light_green, c_light_red, c_pink, c_red, c_white, mtype::color, detail::count(), monster_visible_info::dangerous, mtype::difficulty, avatar::get_mon_visible(), catacurses::getmaxx(), catacurses::getmaxy(), mvwprintz(), om_direction::name(), mtype::nname(), NPCATT_FOLLOW, NPCATT_KILL, pgettext(), string_format(), mtype::sym, type, u, monster_visible_info::unique_mons, monster_visible_info::unique_types, utf8_width(), point::x, and point::y.

◆ mon_info_update()

void game::mon_info_update ( )

Definition at line 3833 of file game.cpp.

3834{
3835 int newseen = 0;
3836 const int safe_proxy_dist = get_option<int>( "SAFEMODEPROXIMITY" );
3837 const int iProxyDist = ( safe_proxy_dist <= 0 ) ? MAX_VIEW_DISTANCE :
3838 safe_proxy_dist;
3839
3840 monster_visible_info &mon_visible = u.get_mon_visible();
3841 auto &new_seen_mon = mon_visible.new_seen_mon;
3842 auto &unique_types = mon_visible.unique_types;
3843 auto &unique_mons = mon_visible.unique_mons;
3844 auto &dangerous = mon_visible.dangerous;
3845
3846 // 7 0 1 unique_types uses these indices;
3847 // 6 8 2 0-7 are provide by direction_from()
3848 // 5 4 3 8 is used for local monsters (for when we explain them below)
3849 for( auto &t : unique_types ) {
3850 t.clear();
3851 }
3852 for( auto &m : unique_mons ) {
3853 m.clear();
3854 }
3855 std::fill( dangerous, dangerous + 8, false );
3856
3857 const tripoint view = u.pos() + u.view_offset;
3858 new_seen_mon.clear();
3859
3860 // TODO: no reason to have it static here
3861 static time_point previous_turn = calendar::start_of_cataclysm;
3862 const time_duration sm_ignored_time = time_duration::from_turns(
3863 get_option<int>( "SAFEMODEIGNORETURNS" ) );
3864
3866 monster *m = dynamic_cast<monster *>( c );
3867 npc *p = dynamic_cast<npc *>( c );
3868 const direction dir_to_mon = direction_from( view.xy(), point( c->posx(), c->posy() ) );
3869 const int mx = POSX + ( c->posx() - view.x );
3870 const int my = POSY + ( c->posy() - view.y );
3871 int index = 8;
3872 if( !is_valid_in_w_terrain( point( mx, my ) ) ) {
3873 // for compatibility with old code, see diagram below, it explains the values for index,
3874 // also might need revisiting one z-levels are in.
3875 switch( dir_to_mon ) {
3879 index = 7;
3880 break;
3882 case direction::NORTH:
3884 index = 0;
3885 break;
3889 index = 1;
3890 break;
3892 case direction::WEST:
3894 index = 6;
3895 break;
3897 case direction::CENTER:
3899 index = 8;
3900 break;
3902 case direction::EAST:
3904 index = 2;
3905 break;
3909 index = 5;
3910 break;
3912 case direction::SOUTH:
3914 index = 4;
3915 break;
3919 index = 3;
3920 break;
3921 }
3922 }
3923
3924 rule_state safemode_state = RULE_NONE;
3925 const bool safemode_empty = get_safemode().empty();
3926
3927 if( m != nullptr ) {
3928 //Safemode monster check
3929 monster &critter = *m;
3930
3931 const monster_attitude matt = critter.attitude( &u );
3932 const int mon_dist = rl_dist( u.pos(), critter.pos() );
3933 safemode_state = get_safemode().check_monster( critter.name(), critter.attitude_to( u ), mon_dist );
3934
3935 if( ( !safemode_empty && safemode_state == RULE_BLACKLISTED ) || ( safemode_empty &&
3936 ( MATT_ATTACK == matt || MATT_FOLLOW == matt ) ) ) {
3937 if( index < 8 && critter.sees( g->u ) ) {
3938 dangerous[index] = true;
3939 }
3940
3941 if( !safemode_empty || mon_dist <= iProxyDist ) {
3942 bool passmon = false;
3943 if( critter.ignoring > 0 ) {
3944 if( safe_mode != SAFE_MODE_ON ) {
3945 critter.ignoring = 0;
3946 } else if( ( sm_ignored_time == 0_seconds || ( critter.lastseen_turn &&
3947 *critter.lastseen_turn > calendar::turn - sm_ignored_time ) ) &&
3948 ( mon_dist > critter.ignoring / 2 || mon_dist < 6 ) ) {
3949 passmon = true;
3950 }
3951 critter.lastseen_turn = calendar::turn;
3952 }
3953
3954 if( !passmon ) {
3955 newseen++;
3956 new_seen_mon.push_back( shared_from( critter ) );
3957 }
3958 }
3959 }
3960
3961 std::vector<std::pair<const mtype *, int>> &vec = unique_mons[index];
3962 const auto mon_it = std::find_if( vec.begin(), vec.end(),
3963 [&]( const std::pair<const mtype *, int> &elem ) {
3964 return elem.first == critter.type;
3965 } );
3966 if( mon_it == vec.end() ) {
3967 vec.emplace_back( critter.type, 1 );
3968 } else {
3969 mon_it->second++;
3970 }
3971 } else if( p != nullptr ) {
3972 //Safe mode NPC check
3973
3974 const int npc_dist = rl_dist( u.pos(), p->pos() );
3975 safemode_state = get_safemode().check_monster( get_safemode().npc_type_name(), p->attitude_to( u ),
3976 npc_dist );
3977
3978 if( ( !safemode_empty && safemode_state == RULE_BLACKLISTED ) || ( safemode_empty &&
3979 p->get_attitude() == NPCATT_KILL ) ) {
3980 if( !safemode_empty || npc_dist <= iProxyDist ) {
3981 newseen++;
3982 }
3983 }
3984 unique_types[index].push_back( p );
3985 }
3986 }
3987
3988 if( newseen > mostseen ) {
3989 if( newseen - mostseen == 1 ) {
3990 if( !new_seen_mon.empty() ) {
3991 monster &critter = *new_seen_mon.back();
3993 string_format( _( "%s spotted!" ), critter.name() ) );
3994 if( u.has_trait( trait_id( "M_DEFENDER" ) ) && critter.type->in_species( PLANT ) ) {
3995 add_msg( m_warning, _( "We have detected a %s - an enemy of the Mycus!" ), critter.name() );
3997 u.add_effect( effect_adrenaline_mycus, 30_minutes );
3998 } else if( u.get_effect_int( effect_adrenaline_mycus ) == 1 ) {
3999 // Triffids present. We ain't got TIME to adrenaline comedown!
4000 u.add_effect( effect_adrenaline_mycus, 15_minutes );
4001 u.mod_pain( 3 ); // Does take it out of you, though
4002 add_msg( m_info, _( "Our fibers strain with renewed wrath!" ) );
4003 }
4004 }
4005 } else {
4006 //Hostile NPC
4008 _( "Hostile survivor spotted!" ) );
4009 }
4010 } else {
4012 }
4014 if( safe_mode == SAFE_MODE_ON ) {
4016 }
4017 } else if( calendar::turn > previous_turn && get_option<bool>( "AUTOSAFEMODE" ) &&
4018 newseen == 0 ) { // Auto-safe mode, but only if it's a new turn
4019 turnssincelastmon += to_turns<int>( calendar::turn - previous_turn );
4020 if( turnssincelastmon >= get_option<int>( "AUTOSAFEMODETURNS" ) && safe_mode == SAFE_MODE_OFF ) {
4022 add_msg( m_info, _( "Safe mode ON!" ) );
4023 }
4024 }
4025
4026 if( newseen == 0 && safe_mode == SAFE_MODE_STOP ) {
4028 }
4029
4030 previous_turn = calendar::turn;
4031 mostseen = newseen;
4032}
int get_effect_int(const efftype_id &eff_id, body_part bp=num_bp) const
Returns the intensity of the matching effect.
Definition: creature.cpp:1271
virtual bool sees(const Creature &critter) const
The functions check whether this creature can see the target.
Definition: creature.cpp:204
bool cancel_activity_or_ignore_query(distraction_type type, const std::string &text)
Asks if the player wants to cancel their activity and if so cancels it.
Definition: game.cpp:1710
monster_attitude attitude(const Character *u=nullptr) const
Definition: monster.cpp:1091
std::optional< time_point > lastseen_turn
Definition: monster.h:506
Attitude attitude_to(const Creature &other) const override
Attitude (of this creature) towards another creature.
Definition: npc.cpp:2098
rule_state check_monster(const std::string &creature_name_in, Creature::Attitude attitude_in, int proximity_in) const
bool empty() const
rule_state
Definition: enums.h:51
@ RULE_NONE
Definition: enums.h:52
static const species_id PLANT("PLANT")
static const efftype_id effect_adrenaline_mycus("adrenaline_mycus")
bool is_valid_in_w_terrain(point p)
Definition: game.cpp:288
static constexpr int MAPSIZE_X
monster_attitude
Definition: monster.h:55
@ MATT_FOLLOW
Definition: monster.h:61
@ MATT_ATTACK
Definition: monster.h:62
FMT_NOINLINE OutputIt fill(OutputIt it, size_t n, const fill_t< Char > &fill)
bool in_species(const species_id &spec) const
Definition: mtype.cpp:122

References _, ABOVECENTER, ABOVEEAST, ABOVENORTH, ABOVENORTHEAST, ABOVENORTHWEST, ABOVESOUTH, ABOVESOUTHEAST, ABOVESOUTHWEST, ABOVEWEST, Creature::add_effect(), add_msg(), monster::attitude(), monster::attitude_to(), npc::attitude_to(), BELOWCENTER, BELOWEAST, BELOWNORTH, BELOWNORTHEAST, BELOWNORTHWEST, BELOWSOUTH, BELOWSOUTHEAST, BELOWSOUTHWEST, BELOWWEST, c, cancel_activity_or_ignore_query(), CENTER, safemode::check_monster(), monster_visible_info::dangerous, direction_from(), EAST, effect_adrenaline_mycus, safemode::empty(), detail::fill(), time_duration::from_turns(), g, npc::get_attitude(), Creature::get_effect_int(), avatar::get_mon_visible(), get_safemode(), Character::get_visible_creatures(), Creature::has_effect(), Character::has_trait(), hostile_spotted_far, monster::ignoring, mtype::in_species(), is_valid_in_w_terrain(), monster::lastseen_turn, m, m_info, m_warning, MAPSIZE_X, MATT_ATTACK, MATT_FOLLOW, MAX_VIEW_DISTANCE, Character::mod_pain(), mostseen, monster::name(), monster_visible_info::new_seen_mon, NORTH, NORTHEAST, NORTHWEST, NPCATT_KILL, PLANT, Character::pos(), monster::pos(), POSX, POSY, rl_dist(), RULE_BLACKLISTED, RULE_NONE, safe_mode, SAFE_MODE_OFF, SAFE_MODE_ON, SAFE_MODE_STOP, Creature::sees(), set_safe_mode(), shared_from(), SOUTH, SOUTHEAST, SOUTHWEST, calendar::start_of_cataclysm, string_format(), calendar::turn, turnssincelastmon, monster::type, u, monster_visible_info::unique_mons, monster_visible_info::unique_types, player::view_offset, WEST, tripoint::x, tripoint::xy(), and tripoint::y.

Referenced by do_turn().

◆ monmove()

void game::monmove ( )
private

Definition at line 4069 of file game.cpp.

4070{
4071 cleanup_dead();
4072
4073 for( monster &critter : all_monsters() ) {
4074 // Critters in impassable tiles get pushed away, unless it's not impassable for them
4075 if( !critter.is_dead() && m.impassable( critter.pos() ) && !critter.can_move_to( critter.pos() ) ) {
4076 std::string msg = string_format( "%s can't move to its location! %s %s", critter.name(),
4077 critter.pos().to_string(), m.tername( critter.pos() ) );
4078 dbg( DL::Error ) << msg;
4079 add_msg( m_debug, msg );
4080 bool okay = false;
4081 for( const tripoint &dest : m.points_in_radius( critter.pos(), 3 ) ) {
4082 if( critter.can_move_to( dest ) && is_empty( dest ) ) {
4083 critter.setpos( dest );
4084 okay = true;
4085 break;
4086 }
4087 }
4088 if( !okay ) {
4089 // die of "natural" cause (overpopulation is natural)
4090 critter.die( nullptr );
4091 }
4092 }
4093
4094 if( !critter.is_dead() ) {
4095 critter.process_items();
4096 }
4097
4098 if( !critter.is_dead() ) {
4099 critter.process_turn();
4100 }
4101
4102 m.creature_in_field( critter );
4103 if( calendar::once_every( 1_days ) ) {
4104 if( critter.has_flag( MF_MILKABLE ) ) {
4105 critter.refill_udders();
4106 }
4107 critter.try_reproduce();
4108 }
4109 while( critter.moves > 0 && !critter.is_dead() && !critter.has_effect( effect_ridden ) ) {
4110 critter.made_footstep = false;
4111 // Controlled critters don't make their own plans
4112 if( !critter.has_effect( effect_ai_controlled ) ) {
4113 // Formulate a path to follow
4114 critter.plan();
4115 }
4116 critter.move(); // Move one square, possibly hit u
4117 critter.process_triggers();
4118 m.creature_in_field( critter );
4119 }
4120
4121 const bionic_id bio_alarm( "bio_alarm" );
4122 if( !critter.is_dead() &&
4123 u.has_active_bionic( bio_alarm ) &&
4124 u.get_power_level() >= bio_alarm->power_trigger &&
4125 rl_dist( u.pos(), critter.pos() ) <= 5 &&
4126 !critter.is_hallucination() ) {
4127 u.mod_power_level( -bio_alarm->power_trigger );
4128 add_msg( m_warning, _( "Your motion alarm goes off!" ) );
4130 _( "Your motion alarm goes off!" ) );
4131 if( u.has_effect( efftype_id( "sleep" ) ) ) {
4132 u.wake_up();
4133 }
4134 }
4135 }
4136
4137 cleanup_dead();
4138
4139 // The remaining monsters are all alive, but may be outside of the reality bubble.
4140 // If so, despawn them. This is not the same as dying, they will be stored for later and the
4141 // monster::die function is not called.
4142 for( monster &critter : all_monsters() ) {
4143 if( critter.posx() < 0 - ( MAPSIZE_X ) / 6 ||
4144 critter.posy() < 0 - ( MAPSIZE_Y ) / 6 ||
4145 critter.posx() > ( MAPSIZE_X * 7 ) / 6 ||
4146 critter.posy() > ( MAPSIZE_Y * 7 ) / 6 ) {
4147 despawn_monster( critter );
4148 }
4149 }
4150
4151 // Now, do active NPCs.
4152 for( npc &guy : g->all_npcs() ) {
4153 int turns = 0;
4154 if( guy.is_mounted() ) {
4155 guy.check_mount_is_spooked();
4156 }
4157 m.creature_in_field( guy );
4158 if( !guy.has_effect( effect_npc_suspend ) ) {
4159 guy.process_turn();
4160 }
4161 while( !guy.is_dead() && guy.moves > 0 && turns < 10 &&
4162 ( !guy.in_sleep_state() || guy.activity.id() == ACT_OPERATION )
4163 ) {
4164 int moves = guy.moves;
4165 guy.move();
4166 if( moves == guy.moves ) {
4167 // Count every time we exit npc::move() without spending any moves.
4168 turns++;
4169 }
4170
4171 // Turn on debug mode when in infinite loop
4172 // It has to be done before the last turn, otherwise
4173 // there will be no meaningful debug output.
4174 if( turns == 9 ) {
4175 debugmsg( "NPC %s entered infinite loop. Turning on debug mode",
4176 guy.name );
4177 debug_mode = true;
4178 }
4179 }
4180
4181 // If we spun too long trying to decide what to do (without spending moves),
4182 // Invoke cognitive suspension to prevent an infinite loop.
4183 if( turns == 10 ) {
4184 add_msg( _( "%s faints!" ), guy.name );
4185 guy.reboot();
4186 }
4187
4188 if( !guy.is_dead() ) {
4189 guy.npc_update_body();
4190 }
4191 }
4192 cleanup_dead();
4193}
void mod_power_level(const units::energy &npower)
Definition: character.cpp:1919
units::energy get_power_level() const
Definition: character.cpp:1899
void wake_up()
Definition: avatar.cpp:958
static const activity_id ACT_OPERATION("ACT_OPERATION")
static const efftype_id effect_npc_suspend("npc_suspend")
static const efftype_id effect_ai_controlled("ai_controlled")
static constexpr int MAPSIZE_Y
@ MF_MILKABLE
Definition: mtype.h:167

References _, ACT_OPERATION, add_msg(), alert, all_monsters(), cancel_activity_or_ignore_query(), cleanup_dead(), map::creature_in_field(), dbg, debug_mode, debugmsg, despawn_monster(), effect_ai_controlled, effect_npc_suspend, effect_ridden, Error, g, Character::get_power_level(), Character::has_active_bionic(), Creature::has_effect(), map::impassable(), is_empty(), m, m_debug, m_warning, MAPSIZE_X, MAPSIZE_Y, MF_MILKABLE, Character::mod_power_level(), calendar::once_every(), map::points_in_radius(), Character::pos(), bionic_data::power_trigger, rl_dist(), string_format(), map::tername(), u, and avatar::wake_up().

Referenced by do_turn().

◆ mouse_edge_scrolling()

std::pair< tripoint, tripoint > game::mouse_edge_scrolling ( input_context ctxt,
int  speed,
const tripoint last,
bool  iso 
)
private

Definition at line 2036 of file game.cpp.

2038{
2039 const int rate = get_option<int>( "EDGE_SCROLL" );
2040 auto ret = std::make_pair( tripoint_zero, last );
2041 if( rate == -1 ) {
2042 // Fast return when the option is disabled.
2043 return ret;
2044 }
2045 // Ensure the parameters are used even if the #if below is false
2046 ( void ) ctxt;
2047 ( void ) speed;
2048 ( void ) iso;
2049#if (defined TILES || defined _WIN32 || defined WINDOWS)
2050 auto now = std::chrono::steady_clock::now();
2051 if( now < last_mouse_edge_scroll + std::chrono::milliseconds( rate ) ) {
2052 return ret;
2053 } else {
2055 }
2056 const input_event event = ctxt.get_raw_input();
2057 if( event.type == CATA_INPUT_MOUSE ) {
2058 const point threshold( projected_window_width() / 100, projected_window_height() / 100 );
2059 if( event.mouse_pos.x <= threshold.x ) {
2060 ret.first.x -= speed;
2061 if( iso ) {
2062 ret.first.y -= speed;
2063 }
2064 } else if( event.mouse_pos.x >= projected_window_width() - threshold.x ) {
2065 ret.first.x += speed;
2066 if( iso ) {
2067 ret.first.y += speed;
2068 }
2069 }
2070 if( event.mouse_pos.y <= threshold.y ) {
2071 ret.first.y -= speed;
2072 if( iso ) {
2073 ret.first.x += speed;
2074 }
2075 } else if( event.mouse_pos.y >= projected_window_height() - threshold.y ) {
2076 ret.first.y += speed;
2077 if( iso ) {
2078 ret.first.x -= speed;
2079 }
2080 }
2081 ret.second = ret.first;
2082 } else if( event.type == CATA_INPUT_TIMEOUT ) {
2083 ret.first = ret.second;
2084 }
2085#endif
2086 return ret;
2087}
@ CATA_INPUT_TIMEOUT
Definition: input.h:77
@ CATA_INPUT_MOUSE
Definition: input.h:80

References CATA_INPUT_MOUSE, CATA_INPUT_TIMEOUT, input_context::get_raw_input(), iso, last, last_mouse_edge_scroll, cata::hash64_detail::ret, tripoint_zero, point::x, and point::y.

Referenced by mouse_edge_scrolling_overmap(), and mouse_edge_scrolling_terrain().

◆ mouse_edge_scrolling_overmap()

tripoint game::mouse_edge_scrolling_overmap ( input_context ctxt)

This variant is suitable for the overmap.

Definition at line 2098 of file game.cpp.

2099{
2100 // overmap has no iso mode
2104 return ret.first;
2105}
std::pair< tripoint, tripoint > mouse_edge_scrolling(input_context &ctxt, int speed, const tripoint &last, bool iso)
Definition: game.cpp:2036
tripoint last_mouse_edge_scroll_vector_terrain
Definition: game.h:1068
tripoint last_mouse_edge_scroll_vector_overmap
Definition: game.h:1069

References last_mouse_edge_scroll_vector_overmap, last_mouse_edge_scroll_vector_terrain, mouse_edge_scrolling(), cata::hash64_detail::ret, and tripoint_zero.

◆ mouse_edge_scrolling_terrain()

tripoint game::mouse_edge_scrolling_terrain ( input_context ctxt)

Used to implement mouse "edge scrolling".

Returns a tripoint which is a vector of the resulting "move", i.e. (0, 0, 0) if the mouse is not at the edge of the screen, otherwise some (x, y, 0) depending on which edges are hit. This variant adjust scrolling speed according to zoom level, making it suitable when viewing the "terrain".

Definition at line 2089 of file game.cpp.

References DEFAULT_TILESET_ZOOM, last_mouse_edge_scroll_vector_overmap, last_mouse_edge_scroll_vector_terrain, mouse_edge_scrolling(), cata::hash64_detail::ret, tile_iso, tileset_zoom, and tripoint_zero.

Referenced by look_around().

◆ move_save_to_graveyard()

void game::move_save_to_graveyard ( const std::string &  dirname)
private

Definition at line 2479 of file game.cpp.

2480{
2481 const std::string save_dir = get_world_base_save_path();
2482 const std::string graveyard_dir = PATH_INFO::graveyarddir() + "/";
2483 const std::string graveyard_save_dir = graveyard_dir + dirname + "/";
2484 const std::string &prefix = base64_encode( u.get_save_id() ) + ".";
2485
2486 if( !assure_dir_exist( graveyard_dir ) ) {
2487 debugmsg( "could not create graveyard path '%s'", graveyard_dir );
2488 }
2489
2490 if( !assure_dir_exist( graveyard_save_dir ) ) {
2491 debugmsg( "could not create graveyard path '%s'", graveyard_save_dir );
2492 }
2493
2494 const auto save_files = get_files_from_path( prefix, save_dir );
2495 if( save_files.empty() ) {
2496 debugmsg( "could not find save files in '%s'", save_dir );
2497 }
2498
2499 for( const auto &src_path : save_files ) {
2500 const std::string dst_path = graveyard_save_dir +
2501 src_path.substr( src_path.rfind( '/' ), std::string::npos );
2502
2503 if( rename_file( src_path, dst_path ) ) {
2504 continue;
2505 }
2506
2507 debugmsg( "could not rename file '%s' to '%s'", src_path, dst_path );
2508
2509 if( remove_file( src_path ) ) {
2510 continue;
2511 }
2512
2513 debugmsg( "could not remove file '%s'", src_path );
2514 }
2515}
bool remove_file(const std::string &path)
Remove a file.
Definition: filesystem.cpp:89
bool assure_dir_exist(const std::string &path)
Create directory if it does not exist.
Definition: filesystem.cpp:48
bool rename_file(const std::string &old_path, const std::string &new_path)
Rename a file, overwriting the target.
Definition: filesystem.cpp:105
std::vector< std::string > get_files_from_path(const std::string &pattern, const std::string &root_path, const bool recursive_search, const bool match_extension)
Returns a vector of files or directories matching pattern at root_path.
Definition: filesystem.cpp:366
std::string graveyarddir()
Definition: path_info.cpp:202

References assure_dir_exist(), base64_encode(), debugmsg, get_files_from_path(), avatar::get_save_id(), get_world_base_save_path(), PATH_INFO::graveyarddir(), prefix, remove_file(), rename_file(), and u.

Referenced by cleanup_at_end().

◆ moving_vehicle_dismount()

void game::moving_vehicle_dismount ( const tripoint dest_loc)

Handles players exiting from moving vehicles.

Definition at line 5143 of file game.cpp.

5144{
5145 const optional_vpart_position vp = m.veh_at( u.pos() );
5146 if( !vp ) {
5147 debugmsg( "Tried to exit non-existent vehicle." );
5148 return;
5149 }
5150 vehicle *const veh = &vp->vehicle();
5151 if( u.pos() == dest_loc ) {
5152 debugmsg( "Need somewhere to dismount towards." );
5153 return;
5154 }
5155 tileray ray( dest_loc.xy() + point( -u.posx(), -u.posy() ) );
5156 // TODO:: make dir() const correct!
5157 const units::angle d = ray.dir();
5158 add_msg( _( "You dive from the %s." ), veh->name );
5159 m.unboard_vehicle( u.pos() );
5160 u.moves -= 200;
5161 // Dive three tiles in the direction of tox and toy
5162 fling_creature( &u, d, 30, true );
5163 // Hit the ground according to vehicle speed
5164 if( !m.has_flag( "SWIMMABLE", u.pos() ) ) {
5165 if( veh->velocity > 0 ) {
5166 fling_creature( &u, veh->face.dir(), veh->velocity / static_cast<float>( 100 ) );
5167 } else {
5168 fling_creature( &u, veh->face.dir() + 180_degrees,
5169 -( veh->velocity ) / static_cast<float>( 100 ) );
5170 }
5171 }
5172}
void fling_creature(Creature *c, const units::angle &dir, float flvel, bool controlled=false)
Flings the input creature in the given direction.
Definition: game.cpp:9760

References _, add_msg(), debugmsg, tileray::dir(), vehicle::face, fling_creature(), map::has_flag(), m, Creature::moves, vehicle::name, Character::pos(), Character::posx(), Character::posy(), u, map::unboard_vehicle(), map::veh_at(), vehicle::velocity, and tripoint::xy().

◆ natural_light_level()

float game::natural_light_level ( int  zlev) const

Definition at line 3498 of file game.cpp.

3499{
3500 // ignore while underground or above limits
3501 if( zlev > OVERMAP_HEIGHT || zlev < 0 ) {
3502 return LIGHT_AMBIENT_MINIMAL;
3503 }
3504
3505 if( latest_lightlevels[zlev] > -std::numeric_limits<float>::max() ) {
3506 // Already found the light level for now?
3507 return latest_lightlevels[zlev];
3508 }
3509
3510 float ret = LIGHT_AMBIENT_MINIMAL;
3511
3512 // Sunlight/moonlight related stuff
3514 if( !weather.lightning_active ) {
3516 } else {
3517 // Recent lightning strike has lit the area
3519 }
3520
3522
3523 // Artifact light level changes here. Even though some of these only have an effect
3524 // aboveground it is cheaper performance wise to simply iterate through the entire
3525 // list once instead of twice.
3526 float mod_ret = -1;
3527 // Each artifact change does std::max(mod_ret, new val) since a brighter end value
3528 // will trump a lower one.
3529 if( const timed_event *e = timed_events.get( TIMED_EVENT_DIM ) ) {
3530 // TIMED_EVENT_DIM slowly dims the natural sky level, then relights it.
3531 const time_duration left = e->when - calendar::turn;
3532 // TIMED_EVENT_DIM has an occurrence date of turn + 50, so the first 25 dim it,
3533 if( left > 25_turns ) {
3534 mod_ret = std::max( static_cast<double>( mod_ret ), ( ret * ( left - 25_turns ) ) / 25_turns );
3535 // and the last 25 scale back towards normal.
3536 } else {
3537 mod_ret = std::max( static_cast<double>( mod_ret ), ( ret * ( 25_turns - left ) ) / 25_turns );
3538 }
3539 }
3541 // TIMED_EVENT_ARTIFACT_LIGHT causes everywhere to become as bright as day.
3542 mod_ret = std::max<float>( ret, default_daylight_level() );
3543 }
3544 // If we had a changed light level due to an artifact event then it overwrites
3545 // the natural light level.
3546 if( mod_ret > -1 ) {
3547 ret = mod_ret;
3548 }
3549
3550 // Cap everything to our minimum light level
3551 ret = std::max<float>( LIGHT_AMBIENT_MINIMAL, ret );
3552
3553 latest_lightlevels[zlev] = ret;
3554
3555 return ret;
3556}
double default_daylight_level()
How much light is provided in full daylight.
Definition: calendar.cpp:62
float sunlight(const time_point &p, const bool vision)
Returns the current sunlight or moonlight level through the preceding functions.
Definition: calendar.cpp:199
std::array< float, OVERMAP_LAYERS > latest_lightlevels
Definition: game.h:1041
bool queued(timed_event_type type) const
timed_event * get(timed_event_type type)
weather_type_id weather_id
Definition: weather.h:193
static constexpr float LIGHT_AMBIENT_MINIMAL
Definition: lightmap.h:12
@ TIMED_EVENT_DIM
Definition: timed_event.h:22
@ TIMED_EVENT_ARTIFACT_LIGHT
Definition: timed_event.h:23

References default_daylight_level(), timed_event_manager::get(), get_weather, latest_lightlevels, left, LIGHT_AMBIENT_MINIMAL, weather_type::light_modifier, OVERMAP_HEIGHT, timed_event_manager::queued(), cata::hash64_detail::ret, sunlight(), TIMED_EVENT_ARTIFACT_LIGHT, TIMED_EVENT_DIM, timed_events, calendar::turn, and weather_manager::weather_id.

Referenced by light_level().

◆ npc_menu()

bool game::npc_menu ( npc who)

Returns true if the menu handled stuff and player shouldn't do anything else.

Perception slightly increases precision when examining NPCs' wounds Firstaid increases precision when examining NPCs' wounds

Definition at line 5274 of file game.cpp.

5275{
5276 enum choices : int {
5277 talk = 0,
5278 swap_pos,
5279 push,
5280 examine_wounds,
5281 use_item,
5282 sort_armor,
5283 attack,
5284 disarm,
5285 steal
5286 };
5287
5288 const bool obeys = debug_mode || ( who.is_player_ally() && !who.in_sleep_state() );
5289
5290 uilist amenu;
5291
5292 amenu.text = string_format( _( "What to do with %s?" ), who.disp_name() );
5293 amenu.addentry( talk, true, 't', _( "Talk" ) );
5294 amenu.addentry( swap_pos, obeys && !who.is_mounted() &&
5295 !u.is_mounted(), 's', _( "Swap positions" ) );
5296 amenu.addentry( push, obeys && !who.is_mounted(), 'p', _( "Push away" ) );
5297 amenu.addentry( examine_wounds, true, 'w', _( "Examine wounds" ) );
5298 amenu.addentry( use_item, true, 'i', _( "Use item on" ) );
5299 amenu.addentry( sort_armor, obeys, 'r', _( "Sort armor" ) );
5300 amenu.addentry( attack, true, 'a', _( "Attack" ) );
5301 if( !who.is_player_ally() ) {
5302 amenu.addentry( disarm, who.is_armed(), 'd', _( "Disarm" ) );
5303 amenu.addentry( steal, !who.is_enemy(), 'S', _( "Steal" ) );
5304 }
5305
5306 amenu.query();
5307
5308 const int choice = amenu.ret;
5309 if( choice == talk ) {
5310 who.talk_to_u();
5311 } else if( choice == swap_pos ) {
5312 if( !prompt_dangerous_tile( who.pos() ) ) {
5313 return true;
5314 }
5315 // TODO: Make NPCs protest when displaced onto dangerous crap
5316 add_msg( _( "You swap places with %s." ), who.name );
5317 swap_critters( u, who );
5318 // TODO: Make that depend on stuff
5319 u.mod_moves( -200 );
5320 } else if( choice == push ) {
5321 // TODO: Make NPCs protest when displaced onto dangerous crap
5322 tripoint oldpos = who.pos();
5323 who.move_away_from( u.pos(), true );
5324 u.mod_moves( -20 );
5325 if( oldpos != who.pos() ) {
5326 add_msg( _( "%s moves out of the way." ), who.name );
5327 } else {
5328 add_msg( m_warning, _( "%s has nowhere to go!" ), who.name );
5329 }
5330 } else if( choice == examine_wounds ) {
5331 ///\EFFECT_PER slightly increases precision when examining NPCs' wounds
5332
5333 ///\EFFECT_FIRSTAID increases precision when examining NPCs' wounds
5334 const bool precise = u.get_skill_level( skill_firstaid ) * 4 + u.per_cur >= 20;
5335 who.body_window( _( "Limbs of: " ) + who.disp_name(), true, precise, 0, 0, 0, 0.0f, 0.0f, 0.0f,
5336 0.0f, 0.0f );
5337 } else if( choice == use_item ) {
5338 static const std::string heal_string( "heal" );
5339 const auto will_accept = []( const item & it ) {
5340 const auto use_fun = it.get_use( heal_string );
5341 if( use_fun == nullptr ) {
5342 return false;
5343 }
5344
5345 const auto *actor = dynamic_cast<const heal_actor *>( use_fun->get_actor_ptr() );
5346
5347 return actor != nullptr &&
5348 actor->limb_power >= 0 &&
5349 actor->head_power >= 0 &&
5350 actor->torso_power >= 0;
5351 };
5352 item_location loc = game_menus::inv::titled_filter_menu( will_accept, u, _( "Use which item?" ) );
5353
5354 if( !loc ) {
5355 add_msg( _( "Never mind" ) );
5356 return false;
5357 }
5358 item &used = *loc;
5359 bool did_use = u.invoke_item( &used, heal_string, who.pos() );
5360 if( did_use ) {
5361 // Note: exiting a body part selection menu counts as use here
5362 u.mod_moves( -300 );
5363 }
5364 } else if( choice == sort_armor ) {
5365 show_armor_layers_ui( who );
5366 u.mod_moves( -100 );
5367 } else if( choice == attack ) {
5368 if( who.is_enemy() || query_yn( _( "You may be attacked! Proceed?" ) ) ) {
5369 u.melee_attack( who, true );
5370 who.on_attacked( u );
5371 }
5372 } else if( choice == disarm ) {
5373 if( who.is_enemy() || query_yn( _( "You may be attacked! Proceed?" ) ) ) {
5375 }
5376 } else if( choice == steal && query_yn( _( "You may be attacked! Proceed?" ) ) ) {
5378 }
5379
5380 return true;
5381}
hp_part body_window(const std::string &menu_header, bool show_all, bool precise, int normal_bonus, int head_bonus, int torso_bonus, float bleed, float bite, float infect, float bandage_power, float disinfectant_power) const
Displays menu with body part hp, optionally with hp estimation after healing.
Definition: character.cpp:5738
bool in_sleep_state() const override
Definition: character.cpp:9302
void melee_attack(Creature &t, bool allow_special, const matec_id *force_technique=nullptr, bool allow_unarmed=true)
Sets up a melee attack and handles melee attack function calls.
Definition: melee.cpp:416
int per_cur
Definition: character.h:267
bool prompt_dangerous_tile(const tripoint &dest_loc) const
Definition: game.cpp:8700
bool swap_critters(Creature &, Creature &)
Swaps positions of two creatures.
Definition: game.cpp:4769
float limb_power
How much hp to restore when healing limbs?
Definition: iuse_actor.h:1012
void talk_to_u(bool radio_contact=false)
Definition: npctalk.cpp:768
void on_attacked(const Creature &attacker)
Definition: npc.cpp:1462
void move_away_from(const tripoint &p, bool no_bash_atk=false, std::set< tripoint > *nomove=nullptr)
Definition: npcmove.cpp:2567
static const skill_id skill_firstaid("firstaid")
static void swap_pos(Creature &caster, const tripoint &target)
void try_disarm_npc(avatar &you, npc &target)
Try to disarm the NPC.
Definition: melee.cpp:2357
void try_steal_from_npc(avatar &you, npc &target)
Try to steal an item from the NPC's inventory.
Definition: melee.cpp:2434
item_location steal(avatar &you, player &victim)
Menu for stealing stuff.
item_location titled_filter_menu(item_filter filter, avatar &you, const std::string &title, const std::string &none_message="")
void push(monster &z)
Definition: monexamine.cpp:615

References _, add_msg(), uilist::addentry(), Character::body_window(), debug_mode, Character::disp_name(), Character::get_skill_level(), Character::in_sleep_state(), avatar::invoke_item(), Character::is_armed(), npc::is_enemy(), Character::is_mounted(), npc::is_player_ally(), heal_actor::limb_power, m_warning, Character::melee_attack(), Creature::mod_moves(), npc::move_away_from(), Character::name, npc::on_attacked(), Character::per_cur, Character::pos(), prompt_dangerous_tile(), monexamine::push(), uilist::query(), query_yn(), uilist::ret, show_armor_layers_ui(), skill_firstaid, game_menus::inv::steal(), string_format(), swap_critters(), swap_pos(), npc::talk_to_u(), uilist::text, game_menus::inv::titled_filter_menu(), avatar_funcs::try_disarm_npc(), avatar_funcs::try_steal_from_npc(), u, and avatar_action::use_item().

Referenced by examine().

◆ num_creatures()

size_t game::num_creatures ( ) const

Returns the approximate number of creatures in the reality bubble.

Because of performance restrictions it may return a slightly incorrect values (as it includes dead, but not yet cleaned up creatures).

Definition at line 4715 of file game.cpp.

4716{
4717 return critter_tracker->size() + active_npc.size() + 1; // 1 == g->u
4718}

References active_npc, and critter_tracker.

Referenced by display_visibility(), and fungal_effects::fungalize().

◆ on_move_effects()

void game::on_move_effects ( )

Definition at line 9718 of file game.cpp.

9719{
9720 // TODO: Move this to a character method
9721 if( !u.is_mounted() ) {
9722 const item muscle( "muscle" );
9723 for( const bionic_id &bid : u.get_bionic_fueled_with( muscle ) ) {
9724 if( u.has_active_bionic( bid ) ) {// active power gen
9725 u.mod_power_level( units::from_kilojoule( muscle.fuel_energy() ) * bid->fuel_efficiency );
9726 } else if( u.has_bionic( bid ) ) {// passive power gen
9727 u.mod_power_level( units::from_kilojoule( muscle.fuel_energy() ) * bid->passive_fuel_efficiency );
9728 }
9729 }
9730 const bionic_id bio_jointservo( "bio_jointservo" );
9732 if( u.movement_mode_is( CMM_RUN ) ) {
9734 } else {
9736 }
9737 }
9738 }
9739
9740 if( u.movement_mode_is( CMM_RUN ) ) {
9741 if( !u.can_run() ) {
9743 }
9744 }
9745
9746 // apply martial art move bonuses
9747 u.martial_arts_data->ma_onmove_effects( u );
9748
9750}
static const bionic_id bio_jointservo("bio_jointservo")
@ CMM_RUN
Definition: character.h:110
bool can_run()
source of truth of whether a Character can run
Definition: character.cpp:1264
bool movement_mode_is(character_movemode mode) const
Check against the character's current movement mode.
Definition: character.cpp:1554
std::vector< bionic_id > get_bionic_fueled_with(const item &it) const
Return bionic_id of bionics able to use it as fuel.
Definition: character.cpp:1860
bool has_bionic(const bionic_id &b) const
Returns true if the player has the entered bionic id.
Definition: character.cpp:1809
void do_ambient()
Definition: sounds.cpp:1614
constexpr quantity< value_type, energy_in_joule_tag > from_kilojoule(const value_type v)
Definition: units_energy.h:32
units::energy power_trigger
Power cost when the bionic's special effect is triggered.
Definition: bionics.h:43

References bio_jointservo, Character::can_run(), CMM_RUN, sfx::do_ambient(), units::from_kilojoule(), item::fuel_energy(), Character::get_bionic_fueled_with(), Character::has_active_bionic(), Character::has_bionic(), Character::is_mounted(), Character::martial_arts_data, Character::mod_power_level(), Character::movement_mode_is(), bionic_data::power_trigger, avatar::toggle_run_mode(), and u.

Referenced by phasing_move(), and walk_move().

◆ on_options_changed()

void game::on_options_changed ( )

Should be invoked whenever options change.

Definition at line 9752 of file game.cpp.

9753{
9754#if defined(TILES)
9755 tilecontext->on_options_changed();
9756#endif
9757 grid_tracker_ptr->on_options_changed();
9758}

References grid_tracker_ptr.

◆ open_consume_item_menu()

void game::open_consume_item_menu ( )
private

Definition at line 1497 of file handle_action.cpp.

1498{
1499 uilist as_m;
1500
1501 as_m.text = _( "What do you want to consume?" );
1502
1503 as_m.entries.emplace_back( 0, true, 'f', _( "Food" ) );
1504 as_m.entries.emplace_back( 1, true, 'd', _( "Drink" ) );
1505 as_m.entries.emplace_back( 2, true, 'm', _( "Medication" ) );
1506 as_m.query();
1507
1508 switch( as_m.ret ) {
1509 case 0:
1511 break;
1512 case 1:
1514 break;
1515 case 2:
1517 break;
1518 default:
1519 break;
1520 }
1521}
std::vector< uilist_entry > entries
Definition: ui.h:323
item_location consume_drink(player &p)
Consuming a drink item via a custom menu.
item_location consume_meds(player &p)
Consuming a medication item via a custom menu.
item_location consume_food(player &p)
Consuming a food item via a custom menu.

References _, game_menus::inv::consume_drink(), game_menus::inv::consume_food(), game_menus::inv::consume_meds(), avatar_action::eat(), uilist::entries, uilist::query(), uilist::ret, uilist::text, and u.

Referenced by handle_action().

◆ overmap_npc_move()

void game::overmap_npc_move ( )
private

Definition at line 4195 of file game.cpp.

4196{
4197 std::vector<npc *> travelling_npcs;
4198 static constexpr int move_search_radius = 600;
4199 for( auto &elem : overmap_buffer.get_npcs_near_player( move_search_radius ) ) {
4200 if( !elem ) {
4201 continue;
4202 }
4203 npc *npc_to_add = elem.get();
4204 if( ( !npc_to_add->is_active() || rl_dist( u.pos(), npc_to_add->pos() ) > SEEX * 2 ) &&
4205 npc_to_add->mission == NPC_MISSION_TRAVELLING ) {
4206 travelling_npcs.push_back( npc_to_add );
4207 }
4208 }
4209 for( auto &elem : travelling_npcs ) {
4210 if( elem->has_omt_destination() ) {
4211 if( !elem->omt_path.empty() && rl_dist( elem->omt_path.back(), elem->global_omt_location() ) > 2 ) {
4212 //recalculate path, we got distracted doing something else probably
4213 elem->omt_path.clear();
4214 }
4215 if( elem->omt_path.empty() ) {
4216 const tripoint_abs_omt &from = elem->global_omt_location();
4217 const tripoint_abs_omt &to = elem->goal;
4218 elem->omt_path = overmap_buffer.get_travel_path( elem->global_omt_location(), elem->goal,
4220 if( elem->omt_path.empty() ) {
4221 add_msg( m_debug, "%s couldn't find overmap path from %s to %s",
4222 elem->get_name(), from.to_string(), to.to_string() );
4223 elem->goal = npc::no_goal_point;
4224 elem->mission = NPC_MISSION_NULL;
4225 }
4226 } else {
4227 if( elem->omt_path.back() == elem->global_omt_location() ) {
4228 elem->omt_path.pop_back();
4229 }
4230 // TODO: fix point types
4231 elem->travel_overmap(
4232 project_to<coords::sm>( elem->omt_path.back() ).raw() );
4233 }
4234 reload_npcs();
4235 }
4236 }
4237 return;
4238}
std::vector< tripoint_abs_omt > omt_path
Route for overmap scale traveling.
Definition: character.h:1835
static constexpr tripoint_abs_omt no_goal_point
Definition: npc.h:1303
bool is_active() const
Definition: npc.cpp:2216
std::vector< tripoint_abs_omt > get_travel_path(const tripoint_abs_omt &src, const tripoint_abs_omt &dest, overmap_path_params params)
@ NPC_MISSION_NULL
Definition: npc.h:142
@ NPC_MISSION_TRAVELLING
Definition: npc.h:154
static overmap_path_params for_npc()

References add_msg(), overmap_path_params::for_npc(), overmapbuffer::get_npcs_near_player(), overmapbuffer::get_travel_path(), npc::is_active(), m_debug, npc::mission, npc::no_goal_point, NPC_MISSION_NULL, NPC_MISSION_TRAVELLING, Character::omt_path, overmap_buffer, Character::pos(), reload_npcs(), rl_dist(), SEEX, coords::coord_point< Point, Origin, Scale >::to_string(), and u.

Referenced by do_turn().

◆ peek() [1/2]

void game::peek ( )

Definition at line 5634 of file game.cpp.

5635{
5636 const std::optional<tripoint> p = choose_direction( _( "Peek where?" ), true );
5637 if( !p ) {
5638 return;
5639 }
5640
5641 if( p->z != 0 ) {
5642 const tripoint old_pos = u.pos();
5643 vertical_move( p->z, false, true );
5644
5645 if( old_pos != u.pos() ) {
5646 look_around();
5647 vertical_move( p->z * -1, false, true );
5648 }
5649 return;
5650 }
5651
5652 if( m.impassable( u.pos() + *p ) || m.obstructed_by_vehicle_rotation( u.pos(), u.pos() + *p ) ) {
5653 return;
5654 }
5655
5656 peek( u.pos() + *p );
5657}
std::optional< tripoint > choose_direction(const std::string &message, const bool allow_vertical)
Request player input of a direction, possibly including vertical component.
Definition: action.cpp:937

References _, choose_direction(), map::impassable(), look_around(), m, map::obstructed_by_vehicle_rotation(), peek(), Character::pos(), u, and vertical_move().

Referenced by handle_action(), and peek().

◆ peek() [2/2]

void game::peek ( const tripoint p)

Definition at line 5659 of file game.cpp.

5660{
5661 u.moves -= 200;
5662 tripoint prev = u.pos();
5663 u.setpos( p );
5664 tripoint center = p;
5665 const look_around_result result = look_around( /*show_window=*/true, center, center, false, false,
5666 true );
5667 u.setpos( prev );
5668
5669 if( result.peek_action && *result.peek_action == PA_BLIND_THROW ) {
5670 item_location loc;
5671 avatar_action::plthrow( u, loc, p );
5672 }
5674}

References center, map::invalidate_map_cache(), look_around(), m, Creature::moves, PA_BLIND_THROW, avatar_action::plthrow(), Character::pos(), Character::setpos(), u, and tripoint::z.

◆ perhaps_add_random_npc()

void game::perhaps_add_random_npc ( )
private

Definition at line 11059 of file game.cpp.

11060{
11061 static constexpr time_duration spawn_interval = 1_hours;
11062 if( !calendar::once_every( spawn_interval ) ) {
11063 return;
11064 }
11065 // Create a new NPC?
11066 // Only allow NPCs on 0 z-level, otherwise they can bug out due to lack of spots
11067 if( !get_option<bool>( "RANDOM_NPC" ) || ( !m.has_zlevels() && get_levz() != 0 ) ) {
11068 return;
11069 }
11070
11071 // We want the "NPC_DENSITY" to denote number of NPCs per week, per overmap, or so
11072 // But soft-cap it at about a standard year (4*14 days) worth
11073 const int npc_num = overmap_buffer.get_npcs_near_player(
11075 const double chance = npc_overmap::spawn_chance_in_hour( npc_num,
11076 get_option<float>( "NPC_DENSITY" ) );
11077 add_msg( m_debug, "Random NPC spawn chance %0.3f%%", chance * 100 );
11078 if( !x_in_y( chance, 1.0f ) ) {
11079 return;
11080 }
11081
11082 bool spawn_allowed = false;
11084 int counter = 0;
11085 while( !spawn_allowed ) {
11086 if( counter >= 100 ) {
11087 return;
11088 }
11089 // Shouldn't be larger than search radius or it might get swarmy at the edges
11090 static constexpr int radius_spawn_range = npc_overmap::density_search_radius;
11091 const tripoint_abs_omt u_omt = u.global_omt_location();
11092 spawn_point = u_omt + point( rng( -radius_spawn_range, radius_spawn_range ),
11093 rng( -radius_spawn_range, radius_spawn_range ) );
11094 spawn_point.z() = 0;
11095 const oter_id oter = overmap_buffer.ter( spawn_point );
11096 // Shouldn't spawn on lakes or rivers.
11097 // TODO: Prefer greater distance
11098 if( !is_river_or_lake( oter ) || rl_dist( u_omt.xy(), spawn_point.xy() ) < 30 ) {
11099 spawn_allowed = true;
11100 }
11101 counter += 1;
11102 }
11103 shared_ptr_fast<npc> tmp = make_shared_fast<npc>();
11104 tmp->randomize();
11105 std::string new_fac_id = "solo_";
11106 new_fac_id += tmp->name;
11107 // create a new "lone wolf" faction for this one NPC
11108 faction *new_solo_fac = faction_manager_ptr->add_new_faction( tmp->name, faction_id( new_fac_id ),
11109 faction_id( "no_faction" ) );
11110 tmp->set_fac( new_solo_fac ? new_solo_fac->id : faction_id( "no_faction" ) );
11111 // adds the npc to the correct overmap.
11112 // Only spawn random NPCs on z-level 0
11113 // TODO: fix point types
11114 tripoint submap_spawn = omt_to_sm_copy( spawn_point.raw() );
11115 tmp->spawn_at_sm( tripoint( submap_spawn.xy(), 0 ) );
11117 tmp->form_opinion( u );
11118 tmp->mission = NPC_MISSION_NULL;
11119 tmp->long_term_goal_action();
11120 tmp->add_new_mission( mission::reserve_random( ORIGIN_ANY_NPC, tmp->global_omt_location(),
11121 tmp->getID() ) );
11122 dbg( DL::Debug ) << "Spawning a random NPC at " << spawn_point;
11123 // This will make the new NPC active- if its nearby to the player
11124 load_npcs();
11125}
faction_id id
Definition: faction.h:82
point omt_to_sm_copy(point p)
@ Debug
Debug information (default: disabled).
@ ORIGIN_ANY_NPC
Definition: mission.h:46
double spawn_chance_in_hour(int current_npc_count, double density)
Chance that a random NPC spawns somewhere on overmap.
Definition: game.cpp:11048
static constexpr int density_search_radius
Radius of the area in which we count NPCs for random spawn chance.
Definition: npc.h:1423
bool is_river_or_lake(const oter_id &ter)
Definition: overmap.cpp:563

References add_msg(), dbg, Debug, npc_overmap::density_search_radius, faction_manager_ptr, get_levz(), overmapbuffer::get_npcs_near_player(), Character::global_omt_location(), map::has_zlevels(), faction_template::id, overmapbuffer::insert_npc(), is_river_or_lake(), load_npcs(), m, m_debug, NPC_MISSION_NULL, omt_to_sm_copy(), calendar::once_every(), ORIGIN_ANY_NPC, overmap_buffer, mission::reserve_random(), rl_dist(), rng(), npc_overmap::spawn_chance_in_hour(), overmapbuffer::ter(), u, x_in_y(), coords::coord_point< Point, Origin, Scale >::xy(), and tripoint::xy().

Referenced by do_turn().

◆ phasing_move()

bool game::phasing_move ( const tripoint dest,
bool  via_ramp = false 
)

Definition at line 9450 of file game.cpp.

9451{
9452 if( dest_loc.z != u.posz() && !via_ramp ) {
9453 // No vertical phasing yet
9454 return false;
9455 }
9456
9457 //probability travel through walls but not water
9458 tripoint dest = dest_loc;
9459 // tile is impassable
9460 int tunneldist = 0;
9461 const point d( sgn( dest.x - u.posx() ), sgn( dest.y - u.posy() ) );
9462 while( m.impassable( dest ) ||
9463 ( critter_at( dest ) != nullptr && tunneldist > 0 ) ) {
9464 //add 1 to tunnel distance for each impassable tile in the line
9465 tunneldist += 1;
9466 //Being dimensionally anchored prevents quantum shenanigans.
9467 if( u.worn_with_flag( "DIMENSIONAL_ANCHOR" ) || u.has_effect_with_flag( "DIMENSIONAL_ANCHOR" ) ) {
9469 _( "You try to quantum tunnel through the barrier, but something holds you back!" ) );
9470 return false;
9471 }
9472 if( tunneldist > 24 ) {
9473 add_msg( m_info, _( "It's too dangerous to tunnel that far!" ) );
9474 return false;
9475 }
9476
9477 dest.x += d.x;
9478 dest.y += d.y;
9479 }
9480
9482
9483 if( tunneldist != 0 ) {
9484 // -1 because power_cost for the first tile was already taken up by the bionic's activation
9485 if( ( tunneldist - 1 ) * power_cost > u.get_power_level() ) {
9486 // oops, not enough energy! Tunneling costs set amount of bionic power per impassable tile
9487 if( tunneldist * power_cost > u.get_max_power_level() ) {
9488 add_msg( _( "You try to quantum tunnel through the barrier but bounce off! You don't have enough bionic power capacity to travel that far." ) );
9489 } else {
9490 add_msg( _( "You try to quantum tunnel through the barrier but are reflected! You need %s of bionic power to travel that thickness of material." ),
9491 units::display( power_cost * tunneldist ) );
9492 }
9493 return false;
9494 }
9495
9496 if( u.in_vehicle ) {
9497 m.unboard_vehicle( u.pos() );
9498 }
9499
9500 add_msg( _( "You quantum tunnel through the %d-tile wide barrier!" ), tunneldist );
9501 //tunneling costs 100 bionic power per impassable tile, but the first 100 was already drained by activation.
9502 u.mod_power_level( -( ( tunneldist - 1 ) * power_cost ) );
9503 //tunneling costs 100 moves baseline, 50 per extra tile up to a cap of 500 moves
9504 u.moves -= ( 50 + ( tunneldist * 50 ) );
9505 u.setpos( dest );
9506
9507 if( m.veh_at( u.pos() ).part_with_feature( "BOARDABLE", true ) ) {
9508 m.board_vehicle( u.pos(), &u );
9509 }
9510
9511 u.grab( OBJECT_NONE );
9513 m.creature_on_trap( u );
9514 return true;
9515 }
9516
9517 return false;
9518}
bool worn_with_flag(const std::string &flag, const bodypart_id &bp=bodypart_str_id::NULL_ID()) const
Returns true if the player is wearing an item with the given flag.
Definition: character.cpp:3254
units::energy get_max_power_level() const
Definition: character.cpp:1904
bool has_effect_with_flag(const std::string &flag, body_part bp=num_bp) const
Check if creature has any effect with the given flag.
Definition: creature.cpp:1209
void on_move_effects()
Definition: game.cpp:9718
void board_vehicle(const tripoint &p, player *pl)
Definition: map.cpp:1113
constexpr int sgn(const T x)
Definition: enums.h:8
static const bionic_id bio_probability_travel("bio_probability_travel")
std::string display(const units::energy v)
Definition: units.cpp:59
units::energy power_activate
Power cost on activation.
Definition: bionics.h:37

References _, add_msg(), player::add_msg_if_player(), bio_probability_travel, map::board_vehicle(), map::creature_on_trap(), critter_at(), units::display(), Character::get_max_power_level(), Character::get_power_level(), avatar::grab(), Creature::has_effect_with_flag(), map::impassable(), Character::in_vehicle, m, m_info, Character::mod_power_level(), Creature::moves, OBJECT_NONE, on_move_effects(), Character::pos(), Character::posx(), Character::posy(), Character::posz(), bionic_data::power_activate, Character::setpos(), sgn(), u, map::unboard_vehicle(), map::veh_at(), Character::worn_with_flag(), point::x, tripoint::x, point::y, tripoint::y, and tripoint::z.

◆ pickup() [1/2]

void game::pickup ( )
private

Definition at line 5605 of file game.cpp.

5606{
5607 const std::optional<tripoint> examp_ = choose_adjacent_highlight( _( "Pickup where?" ),
5608 _( "There is nothing to pick up nearby." ),
5609 ACTION_PICKUP, false );
5610 if( !examp_ ) {
5611 return;
5612 }
5613 pickup( *examp_ );
5614}

References _, ACTION_PICKUP, choose_adjacent_highlight(), and pickup().

Referenced by handle_action(), and pickup().

◆ pickup() [2/2]

void game::pickup ( const tripoint p)
private

Definition at line 5616 of file game.cpp.

5617{
5618 // Highlight target
5619 shared_ptr_fast<game::draw_callback_t> hilite_cb = make_shared_fast<game::draw_callback_t>( [&]() {
5620 m.drawsq( w_terrain, p, drawsq_params().highlight( true ) );
5621 } );
5622 add_draw_callback( hilite_cb );
5623
5624 pickup::pick_up( p, 0 );
5625}

References add_draw_callback(), map::drawsq(), m, pickup::pick_up(), and w_terrain.

◆ pickup_feet()

void game::pickup_feet ( )
private

Definition at line 5627 of file game.cpp.

5628{
5629 pickup::pick_up( u.pos(), 1 );
5630}

References pickup::pick_up(), Character::pos(), and u.

Referenced by handle_action().

◆ place_critter_around() [1/2]

monster * game::place_critter_around ( const mtype_id id,
const tripoint center,
int  radius 
)

Definition at line 4663 of file game.cpp.

4664{
4665 // TODO: change this into an assert, it must never happen.
4666 if( id.is_null() ) {
4667 return nullptr;
4668 }
4669 return place_critter_around( make_shared_fast<monster>( id ), center, radius );
4670}
monster * place_critter_around(const mtype_id &id, const tripoint &center, int radius)
Definition: game.cpp:4663

References center, and place_critter_around().

Referenced by place_critter_around(), place_critter_at(), replace_stair_monsters(), and start_game().

◆ place_critter_around() [2/2]

monster * game::place_critter_around ( const shared_ptr_fast< monster > &  mon,
const tripoint center,
int  radius,
bool  forced = false 
)

Definition at line 4672 of file game.cpp.

4676{
4677 std::optional<tripoint> where;
4678 if( forced || can_place_monster( *mon, center ) ) {
4679 where = center;
4680 }
4681
4682 // This loop ensures the monster is placed as close to the center as possible,
4683 // but all places that equally far from the center have the same probability.
4684 for( int r = 1; r <= radius && !where; ++r ) {
4686 }
4687
4688 if( !where ) {
4689 return nullptr;
4690 }
4691 mon->spawn( *where );
4692 return critter_tracker->add( mon ) ? mon.get() : nullptr;
4693}
static std::optional< tripoint > choose_where_to_place_monster(const monster &mon, const tripoint_range< tripoint > &range)
Definition: game.cpp:4645
static bool can_place_monster(const monster &mon, const tripoint &p)
Definition: game.cpp:4629

References can_place_monster(), center, choose_where_to_place_monster(), critter_tracker, m, and map::points_in_radius().

◆ place_critter_at() [1/2]

monster * game::place_critter_at ( const mtype_id id,
const tripoint p 
)

Adds critters to the reality bubble, creating them if necessary.

Functions taking a id parameter will construct a monster based on that id, (with default properties). Functions taking a mon parameter will use the supplied monster instance instead (which must not be null). Note: the monster will not be upgraded by these functions, it is placed as is.

place_critter_at will place the creature exactly at the given point.

place_critter_around will place the creature around the center p within the given radius (radius 0 means only the center point is used). The chosen point will be as close to the center as possible.

place_critter_within will place the creature at a random point within that given range. (All points within have equal probability.)

Returns
All functions return null if the creature could not be placed (usually because the target is not suitable for it: may be a solid wall, or air, or already occupied by some creature). If the creature has been placed, it returns a pointer to it (which is the same as the one contained in mon).

Definition at line 4653 of file game.cpp.

4654{
4655 return place_critter_around( id, p, 0 );
4656}

References place_critter_around().

Referenced by fungal_effects::fungalize(), revive_corpse(), fungal_effects::spread_fungus_one_tile(), and update_stair_monsters().

◆ place_critter_at() [2/2]

monster * game::place_critter_at ( const shared_ptr_fast< monster > &  mon,
const tripoint p 
)

Definition at line 4658 of file game.cpp.

4659{
4660 return place_critter_around( mon, p, 0 );
4661}

References place_critter_around().

◆ place_critter_within() [1/2]

monster * game::place_critter_within ( const mtype_id id,
const tripoint_range< tripoint > &  range 
)

Definition at line 4695 of file game.cpp.

4696{
4697 // TODO: change this into an assert, it must never happen.
4698 if( id.is_null() ) {
4699 return nullptr;
4700 }
4701 return place_critter_within( make_shared_fast<monster>( id ), range );
4702}
monster * place_critter_within(const mtype_id &id, const tripoint_range< tripoint > &range)
Definition: game.cpp:4695

References place_critter_within(), and range.

Referenced by place_critter_within().

◆ place_critter_within() [2/2]

monster * game::place_critter_within ( const shared_ptr_fast< monster > &  mon,
const tripoint_range< tripoint > &  range 
)

Definition at line 4704 of file game.cpp.

4706{
4707 const std::optional<tripoint> where = choose_where_to_place_monster( *mon, range );
4708 if( !where ) {
4709 return nullptr;
4710 }
4711 mon->spawn( *where );
4712 return critter_tracker->add( mon ) ? mon.get() : nullptr;
4713}

References choose_where_to_place_monster(), critter_tracker, and range.

◆ place_player()

point game::place_player ( const tripoint dest)
Dexterity increases chance of avoiding cuts on sharp terrain

Definition at line 9088 of file game.cpp.

9089{
9090 const optional_vpart_position vp1 = m.veh_at( dest_loc );
9091 if( const std::optional<std::string> label = vp1.get_label() ) {
9092 add_msg( m_info, _( "Label here: %s" ), *label );
9093 }
9094 std::string signage = m.get_signage( dest_loc );
9095 if( !signage.empty() ) {
9096 if( !u.has_trait( trait_ILLITERATE ) ) {
9097 add_msg( m_info, _( "The sign says: %s" ), signage );
9098 } else {
9099 add_msg( m_info, _( "There is a sign here, but you are unable to read it." ) );
9100 }
9101 }
9102 if( m.has_graffiti_at( dest_loc ) ) {
9103 if( !u.has_trait( trait_ILLITERATE ) ) {
9104 add_msg( m_info, _( "Written here: %s" ), m.graffiti_at( dest_loc ) );
9105 } else {
9106 add_msg( m_info, _( "Something is written here, but you are unable to read it." ) );
9107 }
9108 }
9109 // TODO: Move the stuff below to a Character method so that NPCs can reuse it
9110 if( m.has_flag( "ROUGH", dest_loc ) && ( !u.in_vehicle ) && ( !u.is_mounted() ) ) {
9111 if( one_in( 5 ) && u.get_armor_bash( bodypart_id( "foot_l" ) ) < rng( 2, 5 ) ) {
9112 add_msg( m_bad, _( "You hurt your left foot on the %s!" ),
9113 m.has_flag_ter( "ROUGH", dest_loc ) ? m.tername( dest_loc ) : m.furnname(
9114 dest_loc ) );
9115 u.deal_damage( nullptr, bodypart_id( "foot_l" ), damage_instance( DT_CUT, 1 ) );
9116 }
9117 if( one_in( 5 ) && u.get_armor_bash( bodypart_id( "foot_r" ) ) < rng( 2, 5 ) ) {
9118 add_msg( m_bad, _( "You hurt your right foot on the %s!" ),
9119 m.has_flag_ter( "ROUGH", dest_loc ) ? m.tername( dest_loc ) : m.furnname(
9120 dest_loc ) );
9121 u.deal_damage( nullptr, bodypart_id( "foot_l" ), damage_instance( DT_CUT, 1 ) );
9122 }
9123 }
9124 ///\EFFECT_DEX increases chance of avoiding cuts on sharp terrain
9125 if( m.has_flag( "SHARP", dest_loc ) && !one_in( 3 ) && !x_in_y( 1 + u.dex_cur / 2.0, 40 ) &&
9126 ( !u.in_vehicle && !m.veh_at( dest_loc ) ) && ( !u.has_trait( trait_PARKOUR ) ||
9127 one_in( 4 ) ) && ( u.has_trait( trait_THICKSKIN ) ? !one_in( 8 ) : true ) ) {
9128 if( u.is_mounted() ) {
9129 add_msg( _( "Your %s gets cut!" ), u.mounted_creature->get_name() );
9130 u.mounted_creature->apply_damage( nullptr, bodypart_id( "torso" ), rng( 1, 10 ) );
9131 } else {
9132 const bodypart_id bp = u.get_random_body_part();
9133 if( u.deal_damage( nullptr, bp, damage_instance( DT_CUT, rng( 1, 10 ) ) ).total_damage() > 0 ) {
9134 //~ 1$s - bodypart name in accusative, 2$s is terrain name.
9135 add_msg( m_bad, _( "You cut your %1$s on the %2$s!" ),
9136 body_part_name_accusative( bp->token ),
9137 m.has_flag_ter( "SHARP", dest_loc ) ? m.tername( dest_loc ) : m.furnname(
9138 dest_loc ) );
9139 }
9140 }
9141 }
9142 if( m.has_flag( "UNSTABLE", dest_loc ) && !u.is_mounted() ) {
9143 u.add_effect( effect_bouldering, 1_turns, num_bp );
9144 } else if( u.has_effect( effect_bouldering ) ) {
9146 }
9147 if( m.has_flag_ter_or_furn( TFLAG_NO_SIGHT, dest_loc ) ) {
9148 u.add_effect( effect_no_sight, 1_turns, num_bp );
9149 } else if( u.has_effect( effect_no_sight ) ) {
9151 }
9152
9153 // If we moved out of the nonant, we need update our map data
9154 if( m.has_flag( "SWIMMABLE", dest_loc ) && u.has_effect( effect_onfire ) ) {
9155 add_msg( _( "The water puts out the flames!" ) );
9157 if( u.is_mounted() ) {
9158 monster *mon = u.mounted_creature.get();
9159 if( mon->has_effect( effect_onfire ) ) {
9161 }
9162 }
9163 }
9164
9165 if( monster *const mon_ptr = critter_at<monster>( dest_loc ) ) {
9166 // We displaced a monster. It's probably a bug if it wasn't a friendly mon...
9167 // Immobile monsters can't be displaced.
9168 monster &critter = *mon_ptr;
9169 // TODO: handling for ridden creatures other than players mount.
9170 if( !critter.has_effect( effect_ridden ) ) {
9171 if( u.is_mounted() ) {
9172 std::vector<tripoint> valid;
9173 for( const tripoint &jk : m.points_in_radius( critter.pos(), 1 ) ) {
9174 if( is_empty( jk ) ) {
9175 valid.push_back( jk );
9176 }
9177 }
9178 if( !valid.empty() ) {
9179 critter.move_to( random_entry( valid ) );
9180 add_msg( _( "You push the %s out of the way." ), critter.name() );
9181 } else {
9182 add_msg( _( "There is no room to push the %s out of the way." ), critter.name() );
9183 return u.pos().xy();
9184 }
9185 } else {
9186 critter.move_to( u.pos(), false,
9187 true ); // Force the movement even though the player is there right now.
9188 add_msg( _( "You displace the %s." ), critter.name() );
9189 }
9190 } else if( !u.has_effect( effect_riding ) ) {
9191 add_msg( _( "You cannot move the %s out of the way." ), critter.name() );
9192 return u.pos().xy();
9193 }
9194 }
9195
9196 // If the player is in a vehicle, unboard them from the current part
9197 if( u.in_vehicle ) {
9198 m.unboard_vehicle( u.pos() );
9199 }
9200 // Move the player
9201 // Start with z-level, to make it less likely that old functions (2D ones) freak out
9202 if( m.has_zlevels() && dest_loc.z != get_levz() ) {
9203 vertical_shift( dest_loc.z );
9204 }
9205
9206 if( u.is_hauling() && ( !m.can_put_items( dest_loc ) ||
9207 m.has_flag( TFLAG_DEEP_WATER, dest_loc ) ||
9208 vp1 ) ) {
9209 u.stop_hauling();
9210 }
9211 u.setpos( dest_loc );
9212 if( u.is_mounted() ) {
9213 monster *mon = u.mounted_creature.get();
9214 mon->setpos( dest_loc );
9215 mon->process_triggers();
9216 m.creature_in_field( *mon );
9217 }
9218 point submap_shift = update_map( u );
9219 // Important: don't use dest_loc after this line. `update_map` may have shifted the map
9220 // and dest_loc was not adjusted and therefore is still in the un-shifted system and probably wrong.
9221 // If you must use it you can calculate the position in the new, shifted system with
9222 // adjusted_pos = ( old_pos.x - submap_shift.x * SEEX, old_pos.y - submap_shift.y * SEEY, old_pos.z )
9223
9224 //Auto pulp or butcher and Auto foraging
9225 if( get_option<bool>( "AUTO_FEATURES" ) && mostseen == 0 && !u.is_mounted() ) {
9227
9228 const std::string forage_type = get_option<std::string>( "AUTO_FORAGING" );
9229 if( forage_type != "off" ) {
9230 const auto forage = [&]( const tripoint & pos ) {
9231 const auto &xter_t = m.ter( pos ).obj().examine;
9232 const auto &xfurn_t = m.furn( pos ).obj().examine;
9233 const bool forage_everything = forage_type == "both";
9234 const bool forage_bushes = forage_everything || forage_type == "bushes";
9235 const bool forage_trees = forage_everything || forage_type == "trees";
9236 if( xter_t == &iexamine::none && xfurn_t == &iexamine::none ) {
9237 return;
9238 } else if( ( forage_bushes && xter_t == &iexamine::shrub_marloss ) ||
9239 ( forage_bushes && xter_t == &iexamine::shrub_wildveggies ) ||
9240 ( forage_bushes && xter_t == &iexamine::harvest_ter_nectar ) ||
9241 ( forage_trees && xter_t == &iexamine::tree_marloss ) ||
9242 ( forage_trees && xter_t == &iexamine::harvest_ter ) ||
9243 ( forage_trees && xter_t == &iexamine::harvest_ter_nectar )
9244 ) {
9245 xter_t( u, pos );
9246 } else if( ( forage_everything && xfurn_t == &iexamine::harvest_furn ) ||
9247 ( forage_everything && xfurn_t == &iexamine::harvest_furn_nectar )
9248 ) {
9249 xfurn_t( u, pos );
9250 }
9251 };
9252
9253 for( auto &elem : adjacentDir ) {
9254 forage( u.pos() + direction_XY( elem ) );
9255 }
9256 }
9257
9258 const std::string pulp_butcher = get_option<std::string>( "AUTO_PULP_BUTCHER" );
9259 if( pulp_butcher == "butcher" && u.max_quality( quality_id( "BUTCHER" ) ) > INT_MIN ) {
9260 std::vector<item *> corpses;
9261
9262 for( item &it : m.i_at( u.pos() ) ) {
9263 corpses.push_back( &it );
9264 }
9265
9266 if( !corpses.empty() ) {
9267 u.assign_activity( activity_id( "ACT_BUTCHER" ), 0, true );
9268 for( item *it : corpses ) {
9269 u.activity.targets.emplace_back( map_cursor( u.pos() ), it );
9270 }
9271 }
9272 } else if( pulp_butcher == "pulp" || pulp_butcher == "pulp_adjacent" ) {
9273 const auto pulp = [&]( const tripoint & pos ) {
9274 for( const auto &maybe_corpse : m.i_at( pos ) ) {
9275 if( maybe_corpse.is_corpse() && maybe_corpse.can_revive() &&
9276 !maybe_corpse.get_mtype()->bloodType().obj().has_acid ) {
9278 u.activity.placement = m.getabs( pos );
9279 u.activity.auto_resume = true;
9280 u.activity.str_values.push_back( "auto_pulp_no_acid" );
9281 return;
9282 }
9283 }
9284 };
9285
9286 if( pulp_butcher == "pulp_adjacent" ) {
9287 for( auto &elem : adjacentDir ) {
9288 pulp( u.pos() + direction_XY( elem ) );
9289 }
9290 } else {
9291 pulp( u.pos() );
9292 }
9293 }
9294 }
9295
9296 //Autopickup
9297 if( !u.is_mounted() && get_option<bool>( "AUTO_PICKUP" ) && !u.is_hauling() &&
9298 ( !get_option<bool>( "AUTO_PICKUP_SAFEMODE" ) || mostseen == 0 ) &&
9299 ( m.has_items( u.pos() ) || get_option<bool>( "AUTO_PICKUP_ADJACENT" ) ) ) {
9300 pickup::pick_up( u.pos(), -1 );
9301 }
9302
9303 // If the new tile is a boardable part, board it
9304 if( vp1.part_with_feature( "BOARDABLE", true ) && !u.is_mounted() ) {
9305 m.board_vehicle( u.pos(), &u );
9306 }
9307
9308 // Traps!
9309 // Try to detect.
9311 if( u.is_mounted() ) {
9313 } else {
9314 m.creature_on_trap( u );
9315 }
9316 // Drench the player if swimmable
9317 if( m.has_flag( "SWIMMABLE", u.pos() ) &&
9318 !( u.is_mounted() || ( u.in_vehicle && vp1->vehicle().can_float() ) ) ) {
9319 u.drench( 40, { { bp_foot_l, bp_foot_r, bp_leg_l, bp_leg_r } }, false );
9320 }
9321
9322 // List items here
9323 if( !m.has_flag( "SEALED", u.pos() ) ) {
9324 if( get_option<bool>( "NO_AUTO_PICKUP_ZONES_LIST_ITEMS" ) ||
9325 !check_zone( zone_type_id( "NO_AUTO_PICKUP" ), u.pos() ) ) {
9326 if( u.is_blind() && !m.i_at( u.pos() ).empty() ) {
9327 add_msg( _( "There's something here, but you can't see what it is." ) );
9328 } else if( m.has_items( u.pos() ) ) {
9329 std::vector<std::string> names;
9330 std::vector<size_t> counts;
9331 std::vector<item> items;
9332 for( auto &tmpitem : m.i_at( u.pos() ) ) {
9333
9334 std::string next_tname = tmpitem.tname();
9335 std::string next_dname = tmpitem.display_name();
9336 bool by_charges = tmpitem.count_by_charges();
9337 bool got_it = false;
9338 for( size_t i = 0; i < names.size(); ++i ) {
9339 if( by_charges && next_tname == names[i] ) {
9340 counts[i] += tmpitem.charges;
9341 got_it = true;
9342 break;
9343 } else if( next_dname == names[i] ) {
9344 counts[i] += 1;
9345 got_it = true;
9346 break;
9347 }
9348 }
9349 if( !got_it ) {
9350 if( by_charges ) {
9351 names.push_back( tmpitem.tname( tmpitem.charges ) );
9352 counts.push_back( tmpitem.charges );
9353 } else {
9354 names.push_back( tmpitem.display_name( 1 ) );
9355 counts.push_back( 1 );
9356 }
9357 items.push_back( tmpitem );
9358 }
9359 if( names.size() > 10 ) {
9360 break;
9361 }
9362 }
9363 for( size_t i = 0; i < names.size(); ++i ) {
9364 if( !items[i].count_by_charges() ) {
9365 names[i] = items[i].display_name( counts[i] );
9366 } else {
9367 names[i] = items[i].tname( counts[i] );
9368 }
9369 }
9370 int and_the_rest = 0;
9371 for( size_t i = 0; i < names.size(); ++i ) {
9372 //~ number of items: "<number> <item>"
9373 std::string fmt = vgettext( "%1$d %2$s", "%1$d %2$s", counts[i] );
9374 names[i] = string_format( fmt, counts[i], names[i] );
9375 // Skip the first two.
9376 if( i > 1 ) {
9377 and_the_rest += counts[i];
9378 }
9379 }
9380 if( names.size() == 1 ) {
9381 add_msg( _( "You see here %s." ), names[0] );
9382 } else if( names.size() == 2 ) {
9383 add_msg( _( "You see here %s and %s." ), names[0], names[1] );
9384 } else if( names.size() == 3 ) {
9385 add_msg( _( "You see here %s, %s, and %s." ), names[0], names[1], names[2] );
9386 } else if( and_the_rest < 7 ) {
9387 add_msg( vgettext( "You see here %s, %s and %d more item.",
9388 "You see here %s, %s and %d more items.",
9389 and_the_rest ),
9390 names[0], names[1], and_the_rest );
9391 } else {
9392 add_msg( _( "You see here %s and many more items." ), names[0] );
9393 }
9394 }
9395 }
9396 }
9397
9398 if( ( vp1.part_with_feature( "CONTROL_ANIMAL", true ) ||
9399 vp1.part_with_feature( "CONTROLS", true ) ) && u.in_vehicle && !u.is_mounted() ) {
9400 add_msg( _( "There are vehicle controls here." ) );
9401 if( !u.has_trait( trait_id( "WAYFARER" ) ) ) {
9402 add_msg( m_info, _( "%s to drive." ), press_x( ACTION_CONTROL_VEHICLE ) );
9403 }
9404 } else if( vp1.part_with_feature( "CONTROLS", true ) && u.in_vehicle &&
9405 u.is_mounted() ) {
9406 add_msg( _( "There are vehicle controls here but you cannot reach them whilst mounted." ) );
9407 }
9408 return submap_shift;
9409}
std::string body_part_name_accusative(body_part bp, int number)
Returns the matching accusative name of the body_part token, i.e.
Definition: bodypart.cpp:331
void drench(int saturation, const body_part_set &flags, bool ignore_waterproof)
Drenches the player with water, saturation is the percent gotten wet.
Definition: suffer.cpp:1815
bool is_hauling() const
Definition: character.cpp:9166
void stop_hauling()
Definition: character.cpp:9157
bodypart_id get_random_body_part(bool main=false) const
Definition: creature.cpp:1642
void vertical_shift(int z_after)
Actual z-level movement part of vertical_move.
Definition: game.cpp:10571
bool check_zone(const zone_type_id &type, const tripoint &where) const
Definition: game.cpp:6020
std::string furnname(const tripoint &p)
Definition: map.cpp:1533
bool has_flag_ter_or_furn(const std::string &flag, const tripoint &p) const
Definition: map.cpp:2403
bool has_graffiti_at(const tripoint &p) const
Definition: map.cpp:7951
bool has_items(const tripoint &p) const
Checks for existence of items.
Definition: map.cpp:4869
const std::string & graffiti_at(const tripoint &p) const
Definition: map.cpp:7940
bool has_flag_ter(const std::string &flag, const tripoint &p) const
Definition: map.cpp:2393
bool can_put_items(const tripoint &p) const
Definition: map.cpp:2379
void setpos(const tripoint &p) override
Definition: monster.cpp:234
bool move_to(const tripoint &p, bool force=false, bool step_on_critter=false, float stagger_adjustment=1.0)
Attempt to move to p.
Definition: monmove.cpp:1553
void process_triggers()
Definition: monster.cpp:1232
std::optional< std::string > get_label() const
std::vector< std::string > str_values
bool auto_resume
If true, the activity will be auto-resumed next time the player attempts an identical activity.
static const efftype_id effect_riding("riding")
static const trait_id trait_ILLITERATE("ILLITERATE")
static const efftype_id effect_bouldering("bouldering")
static const trait_id trait_PARKOUR("PARKOUR")
static const efftype_id effect_no_sight("no_sight")
static const trait_id trait_THICKSKIN("THICKSKIN")
static const efftype_id effect_onfire("onfire")
point direction_XY(const direction dir)
Definition: line.cpp:433
@ TFLAG_NO_SIGHT
Definition: mapdata.h:283
@ TFLAG_DEEP_WATER
Definition: mapdata.h:301
static std::map< nameFlags, std::vector< std::string > > names
Definition: name.cpp:18
const int INDEFINITELY_LONG
A number that represents the longest possible action.
void search_surroundings(Character &who)
Search surrounding squares for traps (and maybe other things in the future).
void shrub_wildveggies(player &p, const tripoint &examp)
Definition: iexamine.cpp:3683
void shrub_marloss(player &p, const tripoint &examp)
Definition: iexamine.cpp:3648
void harvest_ter(player &p, const tripoint &examp)
Definition: iexamine.cpp:2120
void harvest_furn(player &p, const tripoint &examp)
Definition: iexamine.cpp:2099
void harvest_ter_nectar(player &p, const tripoint &examp)
Definition: iexamine.cpp:2108
void harvest_furn_nectar(player &p, const tripoint &examp)
Definition: iexamine.cpp:2090
void tree_marloss(player &p, const tripoint &examp)
Definition: iexamine.cpp:3662
string_id< zone_type > zone_type_id
Definition: type_id.h:202

References _, ACTION_CONTROL_VEHICLE, Character::activity, Creature::add_effect(), add_msg(), Character::assign_activity(), player_activity::auto_resume, map::board_vehicle(), body_part_name_accusative(), bp_foot_l, bp_foot_r, bp_leg_l, bp_leg_r, map::can_put_items(), check_zone(), map::creature_in_field(), map::creature_on_trap(), Character::deal_damage(), Character::dex_cur, direction_XY(), Character::drench(), DT_CUT, EAST, effect_bouldering, effect_no_sight, effect_onfire, effect_ridden, effect_riding, item_stack::empty(), map_data_common_t::examine, map::furn(), map::furnname(), Character::get_armor_bash(), optional_vpart_position::get_label(), get_levz(), Creature::get_random_body_part(), map::get_signage(), map::getabs(), map::graffiti_at(), iexamine::harvest_furn(), iexamine::harvest_furn_nectar(), iexamine::harvest_ter(), iexamine::harvest_ter_nectar(), Creature::has_effect(), map::has_flag(), map::has_flag_ter(), map::has_flag_ter_or_furn(), map::has_graffiti_at(), map::has_items(), Character::has_trait(), map::has_zlevels(), map::i_at(), Character::in_vehicle, calendar::INDEFINITELY_LONG, Character::is_blind(), is_empty(), Character::is_hauling(), Character::is_mounted(), m, m_bad, m_info, visitable< T >::max_quality(), mostseen, Character::mounted_creature, monster::move_to(), monster::name(), Name::names, iexamine::none(), NORTH, NORTHEAST, NORTHWEST, num_bp, int_id< T >::obj(), one_in(), optional_vpart_position::part_with_feature(), pickup::pick_up(), player_activity::placement, map::points_in_radius(), Character::pos(), monster::pos(), press_x(), monster::process_triggers(), random_entry(), Creature::remove_effect(), rng(), character_funcs::search_surroundings(), Character::setpos(), monster::setpos(), iexamine::shrub_marloss(), iexamine::shrub_wildveggies(), SOUTH, SOUTHEAST, SOUTHWEST, Character::stop_hauling(), player_activity::str_values, string_format(), player_activity::targets, map::ter(), map::tername(), TFLAG_DEEP_WATER, TFLAG_NO_SIGHT, trait_ILLITERATE, trait_PARKOUR, trait_THICKSKIN, iexamine::tree_marloss(), u, map::unboard_vehicle(), update_map(), map::veh_at(), vertical_shift(), vgettext(), WEST, x_in_y(), tripoint::xy(), and tripoint::z.

Referenced by place_player_overmap(), and walk_move().

◆ place_player_overmap()

void game::place_player_overmap ( const tripoint_abs_omt om_dest)

Definition at line 9411 of file game.cpp.

9412{
9413 // if player is teleporting around, they don't bring their horse with them
9414 if( u.is_mounted() ) {
9416 u.mounted_creature->remove_effect( effect_ridden );
9417 u.mounted_creature = nullptr;
9418 }
9419 // offload the active npcs.
9420 unload_npcs();
9421 for( monster &critter : all_monsters() ) {
9422 despawn_monster( critter );
9423 }
9424 if( u.in_vehicle ) {
9425 m.unboard_vehicle( u.pos() );
9426 }
9427
9429 const int minz = m.has_zlevels() ? -OVERMAP_DEPTH : get_levz();
9430 const int maxz = m.has_zlevels() ? OVERMAP_HEIGHT : get_levz();
9431 for( int z = minz; z <= maxz; z++ ) {
9432 m.clear_vehicle_list( z );
9433 }
9435 // offset because load_map expects the coordinates of the top left corner, but the
9436 // player will be centered in the middle of the map.
9437 // TODO: fix point types
9438 const tripoint map_sm_pos(
9439 project_to<coords::sm>( om_dest ).raw() + point( -HALF_MAPSIZE, -HALF_MAPSIZE ) );
9440 const tripoint player_pos( u.pos().xy(), map_sm_pos.z );
9441 load_map( map_sm_pos );
9442 load_npcs();
9443 m.spawn_monsters( true ); // Static monsters
9445 // update weather now as it could be different on the new location
9447 place_player( player_pos );
9448}
point place_player(const tripoint &dest)
Definition: game.cpp:9088
void unload_npcs()
Unloads all NPCs.
Definition: game.cpp:869
void update_overmap_seen()
Definition: game.cpp:10749
level_cache & access_cache(int zlev)
Definition: map.cpp:8861
void clear_vehicle_list(int zlev)
Definition: map.cpp:390
void clear_vehicle_cache()
Definition: map.cpp:372
std::bitset< MAPSIZE_X *MAPSIZE_Y > map_memory_seen_cache
Definition: map.h:351

References map::access_cache(), all_monsters(), map::clear_vehicle_cache(), map::clear_vehicle_list(), despawn_monster(), effect_ridden, effect_riding, get_levz(), get_weather, HALF_MAPSIZE, map::has_zlevels(), Character::in_vehicle, Character::is_mounted(), load_map(), load_npcs(), m, level_cache::map_memory_seen_cache, Character::mounted_creature, weather_manager::nextweather, OVERMAP_DEPTH, OVERMAP_HEIGHT, place_player(), Character::pos(), Creature::remove_effect(), map::spawn_monsters(), calendar::turn, u, map::unboard_vehicle(), unload_npcs(), update_overmap_seen(), tripoint::xy(), and tripoint::z.

◆ place_vehicle_nearby()

vehicle * game::place_vehicle_nearby ( const vproto_id id,
const point_abs_omt origin,
int  min_distance,
int  max_distance,
const std::vector< std::string > &  omt_search_types = {} 
)
private

Definition at line 765 of file game.cpp.

768{
769 std::vector<std::string> search_types = omt_search_types;
770 if( search_types.empty() ) {
771 vehicle veh( id );
772 if( veh.can_float() ) {
773 search_types.push_back( "river" );
774 search_types.push_back( "lake" );
775 } else {
776 search_types.push_back( "field" );
777 search_types.push_back( "road" );
778 }
779 }
780 for( const std::string &search_type : search_types ) {
781 omt_find_params find_params;
782 find_params.must_see = false;
783 find_params.cant_see = false;
784 find_params.types.emplace_back( search_type, ot_match_type::type );
785 // find nearest road
786 find_params.min_distance = min_distance;
787 find_params.search_range = max_distance;
788 // if player spawns underground, park their car on the surface.
789 const tripoint_abs_omt omt_origin( origin, 0 );
790 for( const tripoint_abs_omt &goal : overmap_buffer.find_all( omt_origin, find_params ) ) {
791 // try place vehicle there.
792 tinymap target_map;
793 target_map.load( project_to<coords::sm>( goal ), false );
794 const tripoint tinymap_center( SEEX, SEEY, goal.z() );
795 static constexpr std::array<units::angle, 4> angles = {{
796 0_degrees, 90_degrees, 180_degrees, 270_degrees
797 }
798 };
799 vehicle *veh = target_map.add_vehicle(
800 id, tinymap_center, random_entry( angles ), rng( 50, 80 ), 0, false );
801 if( veh ) {
802 tripoint abs_local = m.getlocal( target_map.getabs( tinymap_center ) );
803 veh->sm_pos = ms_to_sm_remain( abs_local );
804 veh->pos = abs_local.xy();
806 veh->tracking_on = true;
807 target_map.save();
808 return veh;
809 }
810 }
811 }
812 return nullptr;
813}
void save()
Add currently loaded submaps (in grid) to the mapbuffer.
Definition: map.cpp:6706
vehicle * add_vehicle(const vgroup_id &type, const tripoint &p, units::angle dir, int init_veh_fuel=-1, int init_veh_status=-1, bool merge_wrecks=true)
Definition: mapgen.cpp:5429
void add_vehicle(vehicle *veh)
Add the vehicle to be tracked in the overmap.
std::vector< tripoint_abs_omt > find_all(const tripoint_abs_omt &origin, const omt_find_params &params)
Find all places with the specific overmap terrain type.
Definition: map.h:2060
point pos
Position of the vehicle inside the submap that contains the vehicle.
Definition: vehicle.h:1941
tripoint sm_pos
Submap coordinates of the currently loaded submap (see game::m) that contains this vehicle.
Definition: vehicle.h:1926
bool tracking_on
Definition: vehicle.h:2016
point ms_to_sm_remain(int &x, int &y)
static constexpr int SEEY
Standard arguments for finding overmap terrain.
std::vector< std::pair< std::string, ot_match_type > > types

References map::add_vehicle(), overmapbuffer::add_vehicle(), vehicle::can_float(), omt_find_params::cant_see, overmapbuffer::find_all(), map::getabs(), map::getlocal(), map::load(), m, omt_find_params::min_distance, ms_to_sm_remain(), omt_find_params::must_see, overmap_buffer, vehicle::pos, random_entry(), rng(), map::save(), omt_find_params::search_range, SEEX, SEEY, vehicle::sm_pos, vehicle::tracking_on, type, omt_find_params::types, and tripoint::xy().

Referenced by start_game().

◆ pre_print_all_tile_info()

void game::pre_print_all_tile_info ( const tripoint lp,
const catacurses::window w_info,
int &  line,
int  last_line,
const visibility_variables cache 
)

Definition at line 6562 of file game.cpp.

6565{
6566 // get global area info according to look_around caret position
6567 // TODO: fix point types
6569 lp ) ) ) );
6570 // we only need the area name and then pass it to print_all_tile_info() function below
6571 const std::string area_name = cur_ter_m->get_name();
6572 print_all_tile_info( lp, w_info, area_name, 1, first_line, last_line, cache );
6573}
void print_all_tile_info(const tripoint &lp, const catacurses::window &w_look, const std::string &area_name, int column, int &line, int last_line, const visibility_variables &cache)
Definition: game.cpp:5737
point ms_to_omt_copy(point p)
coords::coord_point< tripoint, coords::origin::abs, coords::omt > tripoint_abs_omt
Definition: coordinates.h:493
std::string get_name() const
Definition: omdata.h:205

References oter_t::get_name(), map::getabs(), m, ms_to_omt_copy(), overmap_buffer, print_all_tile_info(), and overmapbuffer::ter().

Referenced by look_around().

◆ print_all_tile_info()

void game::print_all_tile_info ( const tripoint lp,
const catacurses::window w_look,
const std::string &  area_name,
int  column,
int &  line,
int  last_line,
const visibility_variables cache 
)

Definition at line 5737 of file game.cpp.

5742{
5743 visibility_type visibility = VIS_HIDDEN;
5744 const bool inbounds = m.inbounds( lp );
5745 if( inbounds ) {
5746 visibility = m.get_visibility( m.apparent_light_at( lp, cache ), cache );
5747 }
5748 const Creature *creature = critter_at( lp, true );
5749 switch( visibility ) {
5750 case VIS_CLEAR: {
5751 const optional_vpart_position vp = m.veh_at( lp );
5752 print_terrain_info( lp, w_look, area_name, column, line );
5753 print_fields_info( lp, w_look, column, line );
5754 print_trap_info( lp, w_look, column, line );
5755 print_creature_info( creature, w_look, column, line, last_line );
5756 print_vehicle_info( veh_pointer_or_null( vp ), vp ? vp->part_index() : -1, w_look, column, line,
5757 last_line );
5758 print_items_info( lp, w_look, column, line, last_line );
5759 print_graffiti_info( lp, w_look, column, line, last_line );
5760 }
5761 break;
5762 case VIS_BOOMER:
5763 case VIS_BOOMER_DARK:
5764 case VIS_DARK:
5765 case VIS_LIT:
5766 case VIS_HIDDEN:
5767 print_visibility_info( w_look, column, line, visibility );
5768
5769 if( creature != nullptr ) {
5770 std::vector<std::string> buf;
5771 if( u.sees_with_infrared( *creature ) ) {
5772 creature->describe_infrared( buf );
5773 } else if( u.sees_with_specials( *creature ) ) {
5774 creature->describe_specials( buf );
5775 }
5776 for( const std::string &s : buf ) {
5777 mvwprintw( w_look, point( 1, ++line ), s );
5778 }
5779 }
5780 break;
5781 }
5782 if( !inbounds ) {
5783 return;
5784 }
5785 auto this_sound = sounds::sound_at( lp );
5786 if( !this_sound.empty() ) {
5787 mvwprintw( w_look, point( 1, ++line ), _( "You heard %s from here." ), this_sound );
5788 } else {
5789 // Check other z-levels
5790 tripoint tmp = lp;
5791 for( tmp.z = -OVERMAP_DEPTH; tmp.z <= OVERMAP_HEIGHT; tmp.z++ ) {
5792 if( tmp.z == lp.z ) {
5793 continue;
5794 }
5795
5796 auto zlev_sound = sounds::sound_at( tmp );
5797 if( !zlev_sound.empty() ) {
5798 mvwprintw( w_look, point( 1, ++line ), tmp.z > lp.z ?
5799 _( "You heard %s from above." ) : _( "You heard %s from below." ), zlev_sound );
5800 }
5801 }
5802 }
5803}
bool sees_with_specials(const Creature &critter) const
Definition: character.cpp:6346
bool sees_with_infrared(const Creature &critter) const
Check whether the this player can see the other creature with infrared.
void print_fields_info(const tripoint &lp, const catacurses::window &w_look, int column, int &line)
Definition: game.cpp:5910
void print_terrain_info(const tripoint &lp, const catacurses::window &w_look, const std::string &area_name, int column, int &line)
Definition: game.cpp:5834
void print_graffiti_info(const tripoint &lp, const catacurses::window &w_look, int column, int &line, int last_line)
Definition: game.cpp:6004
void print_creature_info(const Creature *creature, const catacurses::window &w_look, int column, int &line, int last_line)
Definition: game.cpp:5948
void print_vehicle_info(const vehicle *veh, int veh_part, const catacurses::window &w_look, int column, int &line, int last_line)
Definition: game.cpp:5957
void print_items_info(const tripoint &lp, const catacurses::window &w_look, int column, int &line, int last_line)
Definition: game.cpp:5966
void print_visibility_info(const catacurses::window &w_look, int column, int &line, visibility_type visibility)
Definition: game.cpp:5805
void print_trap_info(const tripoint &lp, const catacurses::window &w_look, int column, int &line)
Definition: game.cpp:5928
void line(map *m, const ter_id &type, point p1, point p2)
Definition: mapgen.cpp:6281
std::string sound_at(const tripoint &location)
Definition: sounds.cpp:605

References _, map::apparent_light_at(), creature, critter_at(), map::get_visibility(), map::inbounds(), line(), m, catacurses::mvwprintw(), OVERMAP_DEPTH, OVERMAP_HEIGHT, print_creature_info(), print_fields_info(), print_graffiti_info(), print_items_info(), print_terrain_info(), print_trap_info(), print_vehicle_info(), print_visibility_info(), Character::sees_with_infrared(), Character::sees_with_specials(), sounds::sound_at(), u, map::veh_at(), veh_pointer_or_null(), VIS_BOOMER, VIS_BOOMER_DARK, VIS_CLEAR, VIS_DARK, VIS_HIDDEN, VIS_LIT, and tripoint::z.

Referenced by pre_print_all_tile_info().

◆ print_creature_info()

void game::print_creature_info ( const Creature creature,
const catacurses::window w_look,
int  column,
int &  line,
int  last_line 
)
private

Definition at line 5948 of file game.cpp.

5950{
5951 int vLines = last_line - line;
5952 if( creature != nullptr && ( u.sees( *creature ) || creature == &u ) ) {
5953 line = creature->print_info( w_look, ++line, vLines, column );
5954 }
5955}

References creature, line(), Character::sees(), and u.

Referenced by print_all_tile_info().

◆ print_fields_info()

void game::print_fields_info ( const tripoint lp,
const catacurses::window w_look,
int  column,
int &  line 
)
private

Definition at line 5910 of file game.cpp.

5912{
5913 const field &tmpfield = m.field_at( lp );
5914 for( auto &fld : tmpfield ) {
5915 const field_entry &cur = fld.second;
5916 if( fld.first.obj().has_fire && ( m.has_flag( TFLAG_FIRE_CONTAINER, lp ) ||
5917 m.ter( lp ) == t_pit_shallow || m.ter( lp ) == t_pit ) ) {
5918 const int max_width = getmaxx( w_look ) - column - 2;
5919 int lines = fold_and_print( w_look, point( column, ++line ), max_width, cur.color(),
5920 get_fire_fuel_string( lp ) ) - 1;
5921 line += lines;
5922 } else {
5923 mvwprintz( w_look, point( column, ++line ), cur.color(), cur.name() );
5924 }
5925 }
5926}
An active or passive effect existing on a tile.
Definition: field.h:20
nc_color color() const
Definition: field.cpp:94
std::string name() const
Definition: field.h:84
A variable sized collection of field entries on a given map square.
Definition: field.h:131
ter_id t_pit_shallow
Definition: mapdata.cpp:627
ter_id t_pit
Definition: mapdata.cpp:627

References field_entry::color(), map::field_at(), fold_and_print(), get_fire_fuel_string(), catacurses::getmaxx(), map::has_flag(), line(), m, mvwprintz(), field_entry::name(), t_pit, t_pit_shallow, map::ter(), and TFLAG_FIRE_CONTAINER.

Referenced by print_all_tile_info().

◆ print_graffiti_info()

void game::print_graffiti_info ( const tripoint lp,
const catacurses::window w_look,
int  column,
int &  line,
int  last_line 
)
private

Definition at line 6004 of file game.cpp.

6007{
6008 if( line > last_line ) {
6009 return;
6010 }
6011
6012 const int max_width = getmaxx( w_look ) - column - 2;
6013 if( m.has_graffiti_at( lp ) ) {
6014 fold_and_print( w_look, point( column, ++line ), max_width, c_light_gray,
6015 m.ter( lp ) == t_grave_new ? _( "Graffiti: %s" ) : _( "Inscription: %s" ),
6016 m.graffiti_at( lp ) );
6017 }
6018}
ter_id t_grave_new
Definition: mapdata.cpp:627

References _, c_light_gray, fold_and_print(), catacurses::getmaxx(), map::graffiti_at(), map::has_graffiti_at(), line(), m, t_grave_new, and map::ter().

Referenced by print_all_tile_info().

◆ print_items_info()

void game::print_items_info ( const tripoint lp,
const catacurses::window w_look,
int  column,
int &  line,
int  last_line 
)
private

Definition at line 5966 of file game.cpp.

5970{
5971 if( !m.sees_some_items( lp, u ) ) {
5972 return;
5973 } else if( m.has_flag( "CONTAINER", lp ) && !m.could_see_items( lp, u ) ) {
5974 mvwprintw( w_look, point( column, ++line ), _( "You cannot see what is inside of it." ) );
5975 } else if( u.has_effect( effect_blind ) || u.worn_with_flag( "BLIND" ) ) {
5976 mvwprintz( w_look, point( column, ++line ), c_yellow,
5977 _( "There's something there, but you can't see what it is." ) );
5978 return;
5979 } else {
5980 std::map<std::string, int> item_names;
5981 for( auto &item : m.i_at( lp ) ) {
5982 ++item_names[item.tname()];
5983 }
5984
5985 const int max_width = getmaxx( w_look ) - column - 1;
5986 for( auto it = item_names.begin(); it != item_names.end(); ++it ) {
5987 // last line but not last item
5988 if( line + 1 >= last_line && std::next( it ) != item_names.end() ) {
5989 mvwprintz( w_look, point( column, ++line ), c_yellow, _( "More items here…" ) );
5990 break;
5991 }
5992
5993 if( it->second > 1 ) {
5994 trim_and_print( w_look, point( column, ++line ), max_width, c_white,
5995 pgettext( "%s is the name of the item. %d is the quantity of that item.", "%s [%d]" ),
5996 it->first.c_str(), it->second );
5997 } else {
5998 trim_and_print( w_look, point( column, ++line ), max_width, c_white, it->first );
5999 }
6000 }
6001 }
6002}
bool could_see_items(const tripoint &p, const Creature &who) const
Check if the creature could see items at p if there were any items.
Definition: map.cpp:4845
static const efftype_id effect_blind("blind")

References _, c_white, c_yellow, map::could_see_items(), effect_blind, catacurses::getmaxx(), Creature::has_effect(), map::has_flag(), map::i_at(), line(), m, catacurses::mvwprintw(), mvwprintz(), pgettext(), map::sees_some_items(), item::tname(), trim_and_print(), u, and Character::worn_with_flag().

Referenced by print_all_tile_info().

◆ print_terrain_info()

void game::print_terrain_info ( const tripoint lp,
const catacurses::window w_look,
const std::string &  area_name,
int  column,
int &  line 
)
private

Definition at line 5834 of file game.cpp.

5837{
5838 const int max_width = getmaxx( w_look ) - column - 1;
5839 int lines;
5840
5841 const auto fmt_tile_info = []( const tripoint & lp ) {
5842 map &here = get_map();
5843 std::string ret;
5844 if( debug_mode ) {
5845 ret += lp.to_string();
5846 ret += "\n";
5847 }
5848 ret += here.tername( lp );
5850 ret += colorize( string_format( " [%s]", here.ter( lp )->id ), c_light_blue );
5851 }
5852 if( here.has_furn( lp ) ) {
5853 ret += string_format( "; %s", here.furnname( lp ) );
5855 ret += colorize( string_format( " [%s]", here.furn( lp )->id ), c_light_blue );
5856 }
5857 }
5858 return ret;
5859 };
5860
5861 std::string tile = string_format( "(%s) %s", area_name, fmt_tile_info( lp ) );
5862
5863 if( m.impassable( lp ) ) {
5864 lines = fold_and_print( w_look, point( column, line ), max_width, c_light_gray,
5865 _( "%s; Impassable" ),
5866 tile );
5867 } else {
5868 lines = fold_and_print( w_look, point( column, line ), max_width, c_light_gray,
5869 _( "%s; Movement cost %d" ),
5870 tile, m.move_cost( lp ) * 50 );
5871
5872 const auto ll = get_light_level( std::max( 1.0,
5873 LIGHT_AMBIENT_LIT - m.ambient_light_at( lp ) + 1.0 ) );
5874 mvwprintw( w_look, point( column, ++lines ), _( "Lighting: " ) );
5875 wprintz( w_look, ll.second, ll.first );
5876 }
5877
5878 std::string signage = m.get_signage( lp );
5879 if( !signage.empty() ) {
5880 trim_and_print( w_look, point( column, ++lines ), max_width, c_dark_gray,
5881 // NOLINTNEXTLINE(cata-text-style): the question mark does not end a sentence
5882 u.has_trait( trait_ILLITERATE ) ? _( "Sign: ???" ) : _( "Sign: %s" ), signage );
5883 }
5884
5885 if( m.has_zlevels() && lp.z > -OVERMAP_DEPTH && !m.has_floor( lp ) ) {
5886 // Print info about stuff below
5887 tripoint below( lp.xy(), lp.z - 1 );
5888 std::string tile_below = fmt_tile_info( below );
5889
5890 if( !m.has_floor_or_support( lp ) ) {
5891 fold_and_print( w_look, point( column, ++lines ), max_width, c_dark_gray,
5892 _( "Below: %s; No support" ),
5893 tile_below );
5894 } else {
5895 fold_and_print( w_look, point( column, ++lines ), max_width, c_dark_gray,
5896 _( "Below: %s; Walkable" ),
5897 tile_below );
5898 }
5899 }
5900
5901 int map_features = fold_and_print( w_look, point( column, ++lines ), max_width, c_dark_gray,
5902 m.features( lp ) );
5903 fold_and_print( w_look, point( column, ++lines ), max_width, c_light_gray, _( "Coverage: %d%%" ),
5904 m.coverage( lp ) );
5905 if( line < lines ) {
5906 line = lines + map_features - 1;
5907 }
5908}
bool has_floor_or_support(const tripoint &p) const
Definition: map.cpp:2120
float ambient_light_at(const tripoint &p) const
Definition: lightmap.cpp:681
std::string features(const tripoint &p)
Definition: map.cpp:1778
int coverage(const tripoint &p) const
Returns coverage value of the tile.
Definition: map.cpp:6355
int move_cost(const tripoint &p, const vehicle *ignored_vehicle=nullptr) const
Calculate the cost to move past the tile at p.
Definition: map.cpp:1844
static constexpr float LIGHT_AMBIENT_LIT
Definition: lightmap.h:18
std::pair< std::string, nc_color > get_light_level(const float light)
Definition: output.cpp:1621
furn_str_id id
Definition: mapdata.h:500
ter_str_id id
Definition: mapdata.h:465

References _, map::ambient_light_at(), c_dark_gray, c_light_blue, c_light_gray, colorize(), map::coverage(), debug_mode, display_object_ids, map::features(), fold_and_print(), map::furn(), map::furnname(), get_light_level(), get_map, map::get_signage(), catacurses::getmaxx(), map::has_floor(), map::has_floor_or_support(), map::has_furn(), Character::has_trait(), map::has_zlevels(), ter_t::id, furn_t::id, map::impassable(), LIGHT_AMBIENT_LIT, line(), m, map::move_cost(), catacurses::mvwprintw(), OVERMAP_DEPTH, cata::hash64_detail::ret, string_format(), map::ter(), map::tername(), tripoint::to_string(), trait_ILLITERATE, trim_and_print(), u, wprintz(), tripoint::xy(), and tripoint::z.

Referenced by print_all_tile_info().

◆ print_trap_info()

void game::print_trap_info ( const tripoint lp,
const catacurses::window w_look,
int  column,
int &  line 
)
private

Definition at line 5928 of file game.cpp.

5931{
5932 const trap &tr = m.tr_at( lp );
5933 if( tr.can_see( lp, u ) ) {
5934 partial_con *pc = m.partial_con_at( lp );
5935 std::string tr_name;
5936 if( pc && tr.loadid == tr_unfinished_construction ) {
5937 const construction &built = pc->id.obj();
5938 tr_name = string_format( _( "Unfinished task: %s, %d%% complete" ), built.group->name(),
5939 pc->counter / 100000 );
5940 } else {
5941 tr_name = tr.name();
5942 }
5943
5944 mvwprintz( w_look, point( column, ++line ), tr.color, tr_name );
5945 }
5946}
partial_con * partial_con_at(const tripoint &p)
Definition: map.cpp:5252
static const trap_str_id tr_unfinished_construction("tr_unfinished_construction")
std::string name() const
construction_group_str_id group
Definition: construction.h:50
construction_id id
nc_color color
Definition: trap.h:93

References _, trap::can_see(), trap::color, partial_con::counter, construction::group, partial_con::id, line(), trap::loadid, m, mvwprintz(), construction_group::name(), trap::name(), int_id< T >::obj(), map::partial_con_at(), string_format(), map::tr_at(), tr_unfinished_construction, and u.

Referenced by print_all_tile_info().

◆ print_vehicle_info()

void game::print_vehicle_info ( const vehicle veh,
int  veh_part,
const catacurses::window w_look,
int  column,
int &  line,
int  last_line 
)
private

Definition at line 5957 of file game.cpp.

5959{
5960 if( veh ) {
5961 mvwprintw( w_look, point( column, ++line ), _( "There is a %s there. Parts:" ), veh->name );
5962 line = veh->print_part_list( w_look, ++line, last_line, getmaxx( w_look ), veh_part );
5963 }
5964}
int print_part_list(const catacurses::window &win, int y1, int max_y, int width, int p, int hl=-1, bool detail=false) const
Prints a list of all parts to the screen inside of a boxed window, possibly highlighting a selected o...

References _, catacurses::getmaxx(), line(), catacurses::mvwprintw(), vehicle::name, and vehicle::print_part_list().

Referenced by print_all_tile_info().

◆ print_visibility_info()

void game::print_visibility_info ( const catacurses::window w_look,
int  column,
int &  line,
visibility_type  visibility 
)
private

Definition at line 5805 of file game.cpp.

5807{
5808 const char *visibility_message = nullptr;
5809 switch( visibility ) {
5810 case VIS_CLEAR:
5811 visibility_message = _( "Clearly visible." );
5812 break;
5813 case VIS_BOOMER:
5814 visibility_message = _( "A bright pink blur." );
5815 break;
5816 case VIS_BOOMER_DARK:
5817 visibility_message = _( "A pink blur." );
5818 break;
5819 case VIS_DARK:
5820 visibility_message = _( "Darkness." );
5821 break;
5822 case VIS_LIT:
5823 visibility_message = _( "Bright light." );
5824 break;
5825 case VIS_HIDDEN:
5826 visibility_message = _( "Unseen." );
5827 break;
5828 }
5829
5830 mvwprintw( w_look, point( line, column ), visibility_message );
5831 line += 2;
5832}

References _, line(), catacurses::mvwprintw(), VIS_BOOMER, VIS_BOOMER_DARK, VIS_CLEAR, VIS_DARK, VIS_HIDDEN, and VIS_LIT.

Referenced by print_all_tile_info().

◆ process_activity()

void game::process_activity ( )
private

Definition at line 1660 of file game.cpp.

1661{
1662 if( !u.activity ) {
1663 return;
1664 }
1665
1666 while( u.moves > 0 && u.activity ) {
1667 u.activity.do_turn( u );
1668 }
1669}
void do_turn(player &p)
Performs the activity for a single turn.

References Character::activity, player_activity::do_turn(), Creature::moves, and u.

Referenced by do_turn().

◆ process_artifact()

void game::process_artifact ( item it,
player p 
)

Definition at line 11336 of file game.cpp.

11337{
11338 const bool worn = p.is_worn( it );
11339 const bool wielded = ( &it == &p.primary_weapon() );
11340 std::vector<art_effect_passive> effects = it.type->artifact->effects_carried;
11341 if( worn ) {
11342 const std::vector<art_effect_passive> &ew = it.type->artifact->effects_worn;
11343 effects.insert( effects.end(), ew.begin(), ew.end() );
11344 }
11345 if( wielded ) {
11346 const std::vector<art_effect_passive> &ew = it.type->artifact->effects_wielded;
11347 effects.insert( effects.end(), ew.begin(), ew.end() );
11348 }
11349
11350 if( it.is_tool() ) {
11351 // Recharge it if necessary
11352 if( it.ammo_remaining() < it.ammo_capacity() && calendar::once_every( 1_minutes ) ) {
11353 //Before incrementing charge, check that any extra requirements are met
11354 if( check_art_charge_req( it ) ) {
11355 switch( it.type->artifact->charge_type ) {
11356 case ARTC_NULL:
11357 case NUM_ARTCS:
11358 break; // dummy entries
11359 case ARTC_TIME:
11360 // Once per hour
11361 if( calendar::once_every( 1_hours ) ) {
11362 it.charges++;
11363 }
11364 break;
11365 case ARTC_SOLAR:
11366 if( calendar::once_every( 10_minutes ) &&
11367 is_in_sunlight( p.pos() ) ) {
11368 it.charges++;
11369 }
11370 break;
11371 // Artifacts can inflict pain even on Deadened folks.
11372 // Some weird Lovecraftian thing. ;P
11373 // (So DON'T route them through mod_pain!)
11374 case ARTC_PAIN:
11375 if( calendar::once_every( 1_minutes ) ) {
11376 add_msg( m_bad, _( "You suddenly feel sharp pain for no reason." ) );
11377 p.mod_pain_noresist( 3 * rng( 1, 3 ) );
11378 it.charges++;
11379 }
11380 break;
11381 case ARTC_HP:
11382 if( calendar::once_every( 1_minutes ) ) {
11383 add_msg( m_bad, _( "You feel your body decaying." ) );
11384 p.hurtall( 1, nullptr );
11385 it.charges++;
11386 }
11387 break;
11388 case ARTC_FATIGUE:
11389 if( calendar::once_every( 1_minutes ) ) {
11390 add_msg( m_bad, _( "You feel fatigue seeping into your body." ) );
11391 u.mod_fatigue( 3 * rng( 1, 3 ) );
11392 u.mod_stamina( -90 * rng( 1, 3 ) * rng( 1, 3 ) * rng( 2, 3 ) );
11393 it.charges++;
11394 }
11395 break;
11396 // Portals are energetic enough to charge the item.
11397 // Tears in reality are consumed too, but can't charge it.
11398 case ARTC_PORTAL:
11399 for( const tripoint &dest : m.points_in_radius( p.pos(), 1 ) ) {
11400 m.remove_field( dest, fd_fatigue );
11401 if( m.tr_at( dest ).loadid == tr_portal ) {
11402 add_msg( m_good, _( "The portal collapses!" ) );
11403 m.remove_trap( dest );
11404 it.charges++;
11405 break;
11406 }
11407 }
11408 break;
11409 }
11410 }
11411 }
11412 }
11413
11414 for( const art_effect_passive &i : effects ) {
11415 switch( i ) {
11416 case AEP_STR_UP:
11417 p.mod_str_bonus( +4 );
11418 break;
11419 case AEP_DEX_UP:
11420 p.mod_dex_bonus( +4 );
11421 break;
11422 case AEP_PER_UP:
11423 p.mod_per_bonus( +4 );
11424 break;
11425 case AEP_INT_UP:
11426 p.mod_int_bonus( +4 );
11427 break;
11428 case AEP_ALL_UP:
11429 p.mod_str_bonus( +2 );
11430 p.mod_dex_bonus( +2 );
11431 p.mod_per_bonus( +2 );
11432 p.mod_int_bonus( +2 );
11433 break;
11434 case AEP_SPEED_UP:
11435 // Handled in player::current_speed()
11436 break;
11437
11438 case AEP_PBLUE:
11439 if( p.get_rad() > 0 ) {
11440 p.mod_rad( -1 );
11441 }
11442 break;
11443
11444 case AEP_SMOKE:
11445 if( one_in( 10 ) ) {
11446 tripoint pt( p.posx() + rng( -1, 1 ),
11447 p.posy() + rng( -1, 1 ),
11448 p.posz() );
11449 m.add_field( pt, fd_smoke, rng( 1, 3 ) );
11450 }
11451 break;
11452
11453 case AEP_SNAKES:
11454 break; // Handled in player::hit()
11455
11456 case AEP_EXTINGUISH:
11457 for( const tripoint &dest : m.points_in_radius( p.pos(), 1 ) ) {
11458 m.mod_field_age( dest, fd_fire, -1_turns );
11459 }
11460 break;
11461
11462 case AEP_FUN:
11463 //Bonus fluctuates, wavering between 0 and 30-ish - usually around 12
11464 p.add_morale( MORALE_FEELING_GOOD, rng( 1, 2 ) * rng( 2, 3 ), 0, 3_turns, 0_turns, false );
11465 break;
11466
11467 case AEP_HUNGER:
11468 if( one_in( 100 ) ) {
11469 p.mod_stored_kcal( -10 );
11470 }
11471 break;
11472
11473 case AEP_THIRST:
11474 if( one_in( 120 ) ) {
11475 p.mod_thirst( 1 );
11476 }
11477 break;
11478
11479 case AEP_EVIL:
11480 if( one_in( 150 ) ) { // Once every 15 minutes, on average
11481 p.add_effect( effect_evil, 30_minutes );
11482 if( it.is_armor() ) {
11483 if( !worn ) {
11484 add_msg( _( "You have an urge to wear the %s." ),
11485 it.tname() );
11486 }
11487 } else if( !wielded ) {
11488 add_msg( _( "You have an urge to wield the %s." ),
11489 it.tname() );
11490 }
11491 }
11492 break;
11493
11494 case AEP_SCHIZO:
11495 break; // Handled in player::suffer()
11496
11497 case AEP_RADIOACTIVE:
11498 if( one_in( 4 ) ) {
11499 p.irradiate( 1.0f );
11500 }
11501 break;
11502
11503 case AEP_STR_DOWN:
11504 p.mod_str_bonus( -3 );
11505 break;
11506
11507 case AEP_DEX_DOWN:
11508 p.mod_dex_bonus( -3 );
11509 break;
11510
11511 case AEP_PER_DOWN:
11512 p.mod_per_bonus( -3 );
11513 break;
11514
11515 case AEP_INT_DOWN:
11516 p.mod_int_bonus( -3 );
11517 break;
11518
11519 case AEP_ALL_DOWN:
11520 p.mod_str_bonus( -2 );
11521 p.mod_dex_bonus( -2 );
11522 p.mod_per_bonus( -2 );
11523 p.mod_int_bonus( -2 );
11524 break;
11525
11526 case AEP_SPEED_DOWN:
11527 break; // Handled in player::current_speed()
11528
11529 default:
11530 //Suppress warnings
11531 break;
11532 }
11533 }
11534 // Recalculate, as it might have changed (by mod_*_bonus above)
11535 p.str_cur = p.get_str();
11536 p.int_cur = p.get_int();
11537 p.dex_cur = p.get_dex();
11538 p.per_cur = p.get_per();
11539}
@ ARTC_PORTAL
Definition: artifact.h:69
@ ARTC_FATIGUE
Definition: artifact.h:68
@ ARTC_NULL
Definition: artifact.h:63
@ ARTC_SOLAR
Definition: artifact.h:65
@ NUM_ARTCS
Definition: artifact.h:70
@ ARTC_HP
Definition: artifact.h:67
@ ARTC_TIME
Definition: artifact.h:64
@ ARTC_PAIN
Definition: artifact.h:66
virtual void mod_per_bonus(int nper)
Definition: character.cpp:4198
virtual void mod_dex_bonus(int ndex)
Definition: character.cpp:4193
int str_cur
Definition: character.h:264
void mod_rad(int mod)
Definition: character.cpp:7066
virtual int get_dex() const
Definition: character.cpp:4082
virtual void mod_stored_kcal(int nkcal)
Modifiers for need values exclusive to characters.
Definition: character.cpp:4313
bool is_worn(const item &thing) const
Definition: character.h:1099
virtual int get_int() const
Definition: character.cpp:4090
virtual void mod_fatigue(int nfatigue)
Definition: character.cpp:4444
virtual void mod_str_bonus(int nstr)
Definition: character.cpp:4188
int int_cur
Definition: character.h:266
int get_rad() const
Definition: character.cpp:7056
void add_morale(const morale_type &type, int bonus, int max_bonus=0, const time_duration &duration=1_hours, const time_duration &decay_start=30_minutes, bool capped=false, const itype *item_type=nullptr)
Definition: character.cpp:9073
virtual int get_per() const
Definition: character.cpp:4086
void hurtall(int dam, Creature *source, bool disturb=true)
Hurts all body parts for dam, no armor reduction.
Definition: character.cpp:8643
bool irradiate(float rads, bool bypass=false)
Handles mitigation and application of radiation.
Definition: suffer.cpp:1592
virtual void mod_int_bonus(int nint)
Definition: character.cpp:4203
virtual void mod_pain_noresist(int npain)
Definition: creature.cpp:1373
bool is_in_sunlight(const tripoint &p)
Returns true if p is outdoors and it is sunny.
Definition: game.cpp:4845
bool is_tool() const
Definition: item.cpp:6958
int charges
Definition: item.h:2203
bool is_armor() const
Definition: item.cpp:6704
bool add_field(const tripoint &p, const field_type_id &type_id, int intensity=INT_MAX, const time_duration &age=0_turns, bool hit_player=true)
Add field entry at point, or set intensity if present.
Definition: map.cpp:5507
time_duration mod_field_age(const tripoint &p, const field_type_id &type, const time_duration &offset)
Increment/decrement age of field entry at point.
Definition: map.cpp:5427
void remove_trap(const tripoint &p)
Definition: map.cpp:5372
art_effect_passive
Definition: enums.h:99
@ AEP_EXTINGUISH
Definition: enums.h:114
field_type_id fd_smoke
Definition: field_type.cpp:346
field_type_id fd_fatigue
Definition: field_type.cpp:354
static const efftype_id effect_evil("evil")
static const trap_str_id tr_portal("tr_portal")
const morale_type MORALE_FEELING_GOOD("morale_feeling_good")

References _, Creature::add_effect(), map::add_field(), Character::add_morale(), add_msg(), AEP_ALL_DOWN, AEP_ALL_UP, AEP_DEX_DOWN, AEP_DEX_UP, AEP_EVIL, AEP_EXTINGUISH, AEP_FUN, AEP_HUNGER, AEP_INT_DOWN, AEP_INT_UP, AEP_PBLUE, AEP_PER_DOWN, AEP_PER_UP, AEP_RADIOACTIVE, AEP_SCHIZO, AEP_SMOKE, AEP_SNAKES, AEP_SPEED_DOWN, AEP_SPEED_UP, AEP_STR_DOWN, AEP_STR_UP, AEP_THIRST, item::ammo_capacity(), item::ammo_remaining(), ARTC_FATIGUE, ARTC_HP, ARTC_NULL, ARTC_PAIN, ARTC_PORTAL, ARTC_SOLAR, ARTC_TIME, itype::artifact, item::charges, check_art_charge_req(), Character::dex_cur, effect_evil, fd_fatigue, fd_fire, fd_smoke, Character::get_dex(), Character::get_int(), Character::get_per(), Character::get_rad(), Character::get_str(), Character::hurtall(), Character::int_cur, Character::irradiate(), item::is_armor(), is_in_sunlight(), item::is_tool(), Character::is_worn(), trap::loadid, m, m_bad, m_good, Character::mod_dex_bonus(), Character::mod_fatigue(), map::mod_field_age(), Character::mod_int_bonus(), Creature::mod_pain_noresist(), Character::mod_per_bonus(), Character::mod_rad(), Character::mod_stamina(), Character::mod_stored_kcal(), Character::mod_str_bonus(), Character::mod_thirst(), MORALE_FEELING_GOOD, NUM_ARTCS, calendar::once_every(), one_in(), Character::per_cur, map::points_in_radius(), Character::pos(), Character::posx(), Character::posy(), Character::posz(), Character::primary_weapon(), map::remove_field(), map::remove_trap(), rng(), Character::str_cur, item::tname(), map::tr_at(), tr_portal, item::type, and u.

◆ process_voluntary_act_interrupt()

void game::process_voluntary_act_interrupt ( )
private

Definition at line 1620 of file game.cpp.

1621{
1622 if( u.has_effect( effect_sleep ) ) {
1623 // Can't interrupt
1624 return;
1625 }
1626
1627 bool has_activity = u.activity && u.activity.moves_left > 0;
1628 bool is_travelling = u.has_destination() && !u.omt_path.empty();
1629
1630 if( !has_activity && !is_travelling ) {
1631 // Nohing to interrupt
1632 return;
1633 }
1634
1635 // Key poll may be quite expensive, so limit it to 10 times per second.
1636 static auto last_poll = std::chrono::steady_clock::now();
1637 auto now = std::chrono::steady_clock::now();
1638 int64_t difference = std::chrono::duration_cast<std::chrono::milliseconds>
1639 ( now - last_poll ).count();
1640
1641 if( difference > 100 ) {
1643 last_poll = now;
1644 }
1645
1646 // If player is performing a task and a monster is dangerously close, warn them
1647 // regardless of previous safemode warnings.
1648 // Distraction Manager can change this.
1649 if( ( has_activity || is_travelling ) && !u.has_activity( activity_id( "ACT_AIM" ) ) &&
1651 Creature *hostile_critter = is_hostile_very_close();
1652 if( hostile_critter != nullptr ) {
1654 string_format( _( "The %s is dangerously close!" ),
1655 hostile_critter->get_name() ) );
1656 }
1657 }
1658}
bool has_activity(const activity_id &type) const
Check if player currently has a given activity.
Definition: character.cpp:9204
virtual std::string get_name() const =0
void handle_key_blocking_activity()
Definition: game.cpp:1981
int moves_left
The number of moves remaining in this activity before it is complete.

References _, Character::activity, cancel_activity_or_ignore_query(), effect_sleep, Creature::get_name(), handle_key_blocking_activity(), Character::has_activity(), Character::has_destination(), Creature::has_effect(), hostile_spotted_near, player_activity::is_distraction_ignored(), is_hostile_very_close(), player_activity::moves_left, Character::omt_path, string_format(), and u.

Referenced by do_turn().

◆ prompt_dangerous_tile()

bool game::prompt_dangerous_tile ( const tripoint dest_loc) const

Definition at line 8700 of file game.cpp.

8701{
8702 std::vector<std::string> harmful_stuff = get_dangerous_tile( dest_loc );
8703
8704 if( !harmful_stuff.empty() &&
8705 !query_yn( _( "Really step into %s?" ), enumerate_as_string( harmful_stuff ) ) ) {
8706 return false;
8707 }
8708 if( !harmful_stuff.empty() && u.is_mounted() &&
8709 m.tr_at( dest_loc ).loadid == tr_ledge ) {
8710 add_msg( m_warning, _( "Your %s refuses to move over that ledge!" ),
8711 u.mounted_creature->get_name() );
8712 return false;
8713 }
8714 return true;
8715}

References _, add_msg(), enumerate_as_string(), get_dangerous_tile(), Character::is_mounted(), trap::loadid, m, m_warning, Character::mounted_creature, query_yn(), map::tr_at(), tr_ledge, and u.

Referenced by npc_menu(), and walk_move().

◆ quickload()

void game::quickload ( )
private

Definition at line 11304 of file game.cpp.

11305{
11306 const WORLDPTR active_world = world_generator->active_world;
11307 if( active_world == nullptr ) {
11308 return;
11309 }
11310
11311 if( active_world->save_exists( save_t::from_save_id( u.get_save_id() ) ) ) {
11312 if( moves_since_last_save != 0 ) { // See if we need to reload anything
11313 MAPBUFFER.clear();
11315 try {
11316 setup();
11317 } catch( const std::exception &err ) {
11318 debugmsg( "Error: %s", err.what() );
11319 }
11321 }
11322 } else {
11323 popup_getkey( _( "No saves for current character yet." ) );
11324 }
11325}
bool load(const std::string &world)
Attempt to load first valid save (if any) in world.
Definition: game.cpp:2524
void setup()
Definition: game.cpp:477
static save_t from_save_id(const std::string &save_id)
int popup_getkey(const char *const mes, Args &&... args)
Definition: output.h:457
bool save_exists(const save_t &name) const

References _, mapbuffer::clear(), overmapbuffer::clear(), debugmsg, save_t::from_save_id(), avatar::get_save_id(), load(), MAPBUFFER, moves_since_last_save, overmap_buffer, popup_getkey(), WORLD::save_exists(), setup(), u, and world_generator.

Referenced by handle_action().

◆ quicksave()

void game::quicksave ( )

Definition at line 11282 of file game.cpp.

11283{
11284 //Don't autosave if the player hasn't done anything since the last autosave/quicksave,
11285 if( !moves_since_last_save ) {
11286 return;
11287 }
11288 add_msg( m_info, _( "Saving game, this may take a while" ) );
11289
11291 popup.message( "%s", _( "Saving game, this may take a while" ) );
11294
11295 time_t now = time( nullptr ); //timestamp for start of saving procedure
11296
11297 //perform save
11298 save();
11299 //Now reset counters for autosaving, so we don't immediately autosave after a quicksave or autosave.
11301 last_save_timestamp = now;
11302}

References _, add_msg(), last_save_timestamp, m_info, moves_since_last_save, popup(), ui_manager::redraw(), refresh_display(), save(), and time.

Referenced by autosave(), and handle_action().

◆ reenter_fullscreen()

void game::reenter_fullscreen ( )

Definition at line 465 of file game.cpp.

466{
467 if( was_fullscreen ) {
468 if( !fullscreen ) {
470 }
471 }
472}

References fullscreen, toggle_fullscreen(), and was_fullscreen.

Referenced by list_items_monsters(), and look_around().

◆ reload_npcs()

void game::reload_npcs ( )

Unloads, then loads the NPCs.

Definition at line 878 of file game.cpp.

879{
880 // TODO: Make it not invoke the "on_unload" command for the NPCs that will be loaded anyway
881 // and not invoke "on_load" for those NPCs that avoided unloading this way.
882 unload_npcs();
883 load_npcs();
884}

References load_npcs(), and unload_npcs().

Referenced by load(), overmap_npc_move(), vertical_move(), and vertical_shift().

◆ reload_tileset()

void game::reload_tileset ( std::function< void(std::string)>  out)

Definition at line 429 of file game.cpp.

430{
431#if defined(TILES)
432 // Disable UIs below to avoid accessing the tile context during loading.
434 try {
435 tilecontext->reinit();
436 std::vector<mod_id> dummy;
437 tilecontext->load_tileset(
438 get_option<std::string>( "TILES" ),
439 world_generator->active_world ? world_generator->active_world->active_mod_order : dummy,
440 /*precheck=*/false,
441 /*force=*/true,
442 /*pump_events=*/true
443 );
444 tilecontext->do_tile_loading_report( out );
445 } catch( const std::exception &err ) {
446 popup( _( "Loading the tileset failed: %s" ), err.what() );
447 }
448 g->reset_zoom();
449 g->mark_main_ui_adaptor_resize();
450#endif // TILES
451}

References _, g, popup(), and world_generator.

Referenced by handle_action().

◆ remoteveh()

vehicle * game::remoteveh ( )

Returns the current remotely controlled vehicle.

Definition at line 2258 of file game.cpp.

2259{
2261 return remoteveh_cache;
2262 }
2264 std::stringstream remote_veh_string( u.get_value( "remote_controlling_vehicle" ) );
2265 if( remote_veh_string.str().empty() ||
2267 remoteveh_cache = nullptr;
2268 } else {
2269 tripoint vp;
2270 remote_veh_string >> vp.x >> vp.y >> vp.z;
2271 vehicle *veh = veh_pointer_or_null( m.veh_at( vp ) );
2272 if( veh && veh->fuel_left( itype_battery, true ) > 0 ) {
2273 remoteveh_cache = veh;
2274 } else {
2275 remoteveh_cache = nullptr;
2276 }
2277 }
2278 return remoteveh_cache;
2279}
vehicle * remoteveh_cache
Definition: game.h:1044
int fuel_left(const itype_id &ftype, bool recurse=false) const
Definition: vehicle.cpp:3360
static const bionic_id bio_remote("bio_remote")
static const itype_id itype_remotevehcontrol("remotevehcontrol")
static const itype_id itype_battery("battery")

References bio_remote, vehicle::fuel_left(), Creature::get_value(), Character::has_active_bionic(), Character::has_active_item(), itype_battery, itype_remotevehcontrol, m, remoteveh_cache, remoteveh_cache_time, calendar::turn, u, map::veh_at(), veh_pointer_or_null(), tripoint::x, tripoint::y, and tripoint::z.

Referenced by control_vehicle(), and handle_action().

◆ remove_npc_follower()

void game::remove_npc_follower ( const character_id id)

Remove follower id from follower set.

Definition at line 1890 of file game.cpp.

1891{
1892 follower_ids.erase( id );
1893 u.follower_ids.erase( id );
1894}

References follower_ids, player::follower_ids, and u.

Referenced by cleanup_dead().

◆ remove_zombie()

void game::remove_zombie ( const monster critter)

Definition at line 4725 of file game.cpp.

4726{
4727 critter_tracker->remove( critter );
4728}

References critter_tracker.

Referenced by despawn_monster(), disable_robot(), start_game(), and vertical_move().

◆ replace_stair_monsters()

void game::replace_stair_monsters ( )
private

Definition at line 10788 of file game.cpp.

10789{
10790 for( auto &elem : coming_to_stairs ) {
10791 elem.staircount = 0;
10792 const tripoint pnt( elem.pos().xy(), get_levz() );
10793 place_critter_around( make_shared_fast<monster>( elem ), pnt, 10 );
10794 }
10795
10796 coming_to_stairs.clear();
10797}
std::vector< monster > coming_to_stairs
Definition: game.h:982

References coming_to_stairs, get_levz(), and place_critter_around().

◆ reset_item_list_state()

void game::reset_item_list_state ( const catacurses::window window,
int  height,
bool  bRadiusSort 
)
private

Definition at line 7159 of file game.cpp.

7161{
7162 const int width = getmaxx( window );
7163 for( int i = 1; i < TERMX; i++ ) {
7164 if( i < width ) {
7165 mvwputch( window, point( i, 0 ), c_light_gray, LINE_OXOX ); // -
7166 mvwputch( window, point( i, TERMY - height - 1 ), c_light_gray,
7167 LINE_OXOX ); // -
7168 }
7169
7170 if( i < TERMY - height ) {
7171 mvwputch( window, point( 0, i ), c_light_gray, LINE_XOXO ); // |
7172 mvwputch( window, point( width - 1, i ), c_light_gray, LINE_XOXO ); // |
7173 }
7174 }
7175
7176 mvwputch( window, point_zero, c_light_gray, LINE_OXXO ); // |^
7177 mvwputch( window, point( width - 1, 0 ), c_light_gray, LINE_OOXX ); // ^|
7178
7179 mvwputch( window, point( 0, TERMY - height - 1 ), c_light_gray,
7180 LINE_XXXO ); // |-
7181 mvwputch( window, point( width - 1, TERMY - height - 1 ), c_light_gray,
7182 LINE_XOXX ); // -|
7183
7184 mvwprintz( window, point( 2, 0 ), c_light_green, "<Tab> " );
7185 wprintz( window, c_white, _( "Items" ) );
7186
7187 std::string sSort;
7188 if( bRadiusSort ) {
7189 //~ Sort type: distance.
7190 sSort = _( "<s>ort: dist" );
7191 } else {
7192 //~ Sort type: category.
7193 sSort = _( "<s>ort: cat" );
7194 }
7195
7196 int letters = utf8_width( sSort );
7197
7198 shortcut_print( window, point( getmaxx( window ) - letters, 0 ), c_white, c_light_green, sSort );
7199
7200 std::vector<std::string> tokens;
7201 if( !sFilter.empty() ) {
7202 tokens.emplace_back( _( "<R>eset" ) );
7203 }
7204
7205 tokens.emplace_back( _( "<E>xamine" ) );
7206 tokens.emplace_back( _( "<C>ompare" ) );
7207 tokens.emplace_back( _( "<F>ilter" ) );
7208 tokens.emplace_back( _( "<+/->Priority" ) );
7209
7210 int gaps = tokens.size() + 1;
7211 letters = 0;
7212 int n = tokens.size();
7213 for( int i = 0; i < n; i++ ) {
7214 letters += utf8_width( tokens[i] ) - 2; //length ignores < >
7215 }
7216
7217 int usedwidth = letters;
7218 const int gap_spaces = ( width - usedwidth ) / gaps;
7219 usedwidth += gap_spaces * gaps;
7220 point pos( gap_spaces + ( width - usedwidth ) / 2, TERMY - height - 1 );
7221
7222 for( int i = 0; i < n; i++ ) {
7223 pos.x += shortcut_print( window, pos, c_white, c_light_green,
7224 tokens[i] ) + gap_spaces;
7225 }
7226}
#define LINE_OOXX
Definition: output.h:43
#define LINE_OXXO
Definition: output.h:42

References _, c_light_gray, c_light_green, c_white, catacurses::getmaxx(), LINE_OOXX, LINE_OXOX, LINE_OXXO, LINE_XOXO, LINE_XOXX, LINE_XXXO, mvwprintz(), mvwputch(), point_zero, sFilter, shortcut_print(), TERMX, TERMY, utf8_width(), wprintz(), and point::x.

Referenced by list_items().

◆ reset_light_level()

void game::reset_light_level ( )

Definition at line 3564 of file game.cpp.

3565{
3566 for( float &lev : latest_lightlevels ) {
3567 lev = -std::numeric_limits<float>::max();
3568 }
3569}

References latest_lightlevels.

Referenced by do_turn(), and game().

◆ reset_npc_dispositions()

void game::reset_npc_dispositions ( )
private

Definition at line 2636 of file game.cpp.

2637{
2638 for( auto elem : follower_ids ) {
2639 shared_ptr_fast<npc> npc_to_get = overmap_buffer.find_npc( elem );
2640 if( !npc_to_get ) {
2641 continue;
2642 }
2643 npc *npc_to_add = npc_to_get.get();
2644 npc_to_add->chatbin.missions.clear();
2645 npc_to_add->chatbin.missions_assigned.clear();
2646 npc_to_add->mission = NPC_MISSION_NULL;
2647 npc_to_add->chatbin.mission_selected = nullptr;
2648 npc_to_add->set_attitude( NPCATT_NULL );
2649 npc_to_add->op_of_u.anger = 0;
2650 npc_to_add->op_of_u.fear = 0;
2651 npc_to_add->op_of_u.trust = 0;
2652 npc_to_add->op_of_u.value = 0;
2653 npc_to_add->op_of_u.owed = 0;
2654 npc_to_add->set_fac( faction_id( "no_faction" ) );
2656 npc_to_add->global_omt_location(),
2657 npc_to_add->getID() ) );
2658
2659 }
2660
2661}
void set_attitude(npc_attitude new_attitude)
Definition: npc.cpp:3188
npc_chatbin chatbin
Definition: npc.h:1294
void add_new_mission(mission *miss)
See npc_chatbin::add_new_mission.
Definition: npc.cpp:2679
npc_opinion op_of_u
Definition: npc.h:1293
void set_fac(const faction_id &id)
Definition: npc.cpp:477
std::vector< mission * > missions_assigned
Mission that have been assigned by this NPC to a player character.
Definition: npc.h:715
mission * mission_selected
The mission (if any) that we talk about right now.
Definition: npc.h:720
std::vector< mission * > missions
Missions that the NPC can give out.
Definition: npc.h:711
int value
Definition: npc.h:205
int trust
Definition: npc.h:203
int owed
Definition: npc.h:207
int fear
Definition: npc.h:204
int anger
Definition: npc.h:206

References npc::add_new_mission(), npc_opinion::anger, npc::chatbin, npc_opinion::fear, overmapbuffer::find_npc(), follower_ids, Character::getID(), Character::global_omt_location(), npc::mission, npc_chatbin::mission_selected, npc_chatbin::missions, npc_chatbin::missions_assigned, NPC_MISSION_NULL, NPCATT_NULL, npc::op_of_u, ORIGIN_ANY_NPC, overmap_buffer, npc_opinion::owed, mission::reserve_random(), npc::set_attitude(), npc::set_fac(), npc_opinion::trust, and npc_opinion::value.

Referenced by cleanup_at_end().

◆ reset_zoom()

void game::reset_zoom ( )

Definition at line 7074 of file game.cpp.

7075{
7076#if defined(TILES)
7078 rescale_tileset( tileset_zoom );
7079#endif // TILES
7080}

References DEFAULT_TILESET_ZOOM, and tileset_zoom.

◆ revive_corpse()

bool game::revive_corpse ( const tripoint p,
item it 
)

Revives a corpse at given location.

The monster type and some of its properties are deducted from the corpse. If reviving succeeds, the location is guaranteed to have a new monster there (see critter_at).

Parameters
pThe place where to put the revived monster.
itThe corpse item, it must be a valid corpse (see item::is_corpse).
Returns
Whether the corpse has actually been redivided. Reviving may fail for many reasons, including no space to put the monster, corpse being to much damaged etc. If the monster was revived, the caller should remove the corpse item. If reviving failed, the item is unchanged, as is the environment (no new monsters).

Definition at line 4855 of file game.cpp.

4856{
4857 if( !it.is_corpse() ) {
4858 debugmsg( "Tried to revive a non-corpse." );
4859 return false;
4860 }
4861 shared_ptr_fast<monster> newmon_ptr = make_shared_fast<monster>
4862 ( it.get_mtype()->id );
4863 monster &critter = *newmon_ptr;
4864 critter.init_from_item( it );
4865 if( critter.get_hp() < 1 ) {
4866 // Failed reanimation due to corpse being too burned
4867 return false;
4868 }
4869 if( it.has_flag( "FIELD_DRESS" ) || it.has_flag( "FIELD_DRESS_FAILED" ) ||
4870 it.has_flag( "QUARTERED" ) ) {
4871 // Failed reanimation due to corpse being butchered
4872 return false;
4873 }
4874
4875 critter.no_extra_death_drops = true;
4876 critter.add_effect( effect_downed, 5_turns, num_bp );
4877 for( const item &component : it.components ) {
4878 critter.corpse_components.push_back( component );
4879 }
4880
4881 if( it.get_var( "zlave" ) == "zlave" ) {
4882 critter.add_effect( effect_pacified, 1_turns, num_bp );
4883 critter.add_effect( effect_pet, 1_turns, num_bp );
4884 }
4885
4886 if( it.get_var( "no_ammo" ) == "no_ammo" ) {
4887 for( auto &ammo : critter.ammo ) {
4888 ammo.second = 0;
4889 }
4890 }
4891
4892 return place_critter_at( newmon_ptr, p );
4893}
monster * place_critter_at(const mtype_id &id, const tripoint &p)
Adds critters to the reality bubble, creating them if necessary.
Definition: game.cpp:4653
double get_var(const std::string &name, double default_value) const
Definition: item.cpp:1030
const mtype * get_mtype() const
Definition: item.cpp:6625
std::list< item > components
Definition: item.h:2166
bool has_flag(const std::string &flag) const
Definition: item.cpp:5303
bool is_corpse() const
Whether this is a corpse item.
Definition: item.cpp:6620
int get_hp(const bodypart_id &) const override
Definition: monster.cpp:2949
bool no_extra_death_drops
Definition: monster.h:480
std::vector< item > corpse_components
Definition: monster.h:457
void init_from_item(const item &itm)
Initialize values like speed / hp from data of an item.
Definition: monster.cpp:2819
static const efftype_id effect_downed("downed")
static const efftype_id effect_pacified("pacified")

References monster::add_effect(), monster::ammo, item::components, monster::corpse_components, debugmsg, effect_downed, effect_pacified, effect_pet, monster::get_hp(), item::get_mtype(), item::get_var(), item::has_flag(), mtype::id, monster::init_from_item(), item::is_corpse(), monster::no_extra_death_drops, num_bp, and place_critter_at().

◆ save()

bool game::save ( )

Returns false if saving failed.

Definition at line 2737 of file game.cpp.

2738{
2739 try {
2740 if( !save_player_data() ||
2742 !save_artifacts() ||
2743 !save_maps() ||
2744 !get_auto_pickup().save_character() ||
2746 !get_safemode().save_character() ||
2747 !write_to_file( get_world_base_save_path() + "/uistate.json", [&]( std::ostream & fout ) {
2748 JsonOut jsout( fout );
2749 uistate.serialize( jsout );
2750 }, _( "uistate data" ) ) ) {
2751 return false;
2752 } else {
2753 world_generator->last_world_name = world_generator->active_world->world_name;
2754 world_generator->last_character_name = u.name;
2755 world_generator->save_last_world_info();
2756 world_generator->active_world->add_save( save_t::from_save_id( u.get_save_id() ) );
2757 return true;
2758 }
2759 } catch( std::ios::failure &err ) {
2760 popup( _( "Failed to save game data" ) );
2761 return false;
2762 }
2763}
void write_to_file(const std::string &path, const std::function< void(std::ostream &)> &writer)
Definition: json.h:575
bool save_player_data()
Definition: game.cpp:2691
void serialize(JsonOut &json) const
@ failure
Definition: behavior.h:20

References _, behavior::failure, save_t::from_save_id(), get_auto_notes_settings(), get_auto_pickup(), get_safemode(), avatar::get_save_id(), get_world_base_save_path(), Character::name, popup(), save(), save_artifacts(), save_factions_missions_npcs(), save_maps(), save_player_data(), uistatedata::serialize(), u, uistate, world_generator, and write_to_file().

Referenced by handle_action(), quicksave(), and save().

◆ save_artifacts()

bool game::save_artifacts ( )
private

Definition at line 2672 of file game.cpp.

2673{
2674 std::string artfilename = get_world_base_save_path() + "/" + SAVE_ARTIFACTS;
2675 return ::save_artifacts( artfilename );
2676}
bool save_artifacts(const std::string &path)
Definition: artifact.cpp:1277
static const std::string SAVE_ARTIFACTS("artifacts.gsav")

References get_world_base_save_path(), SAVE_ARTIFACTS(), and save_artifacts().

Referenced by cleanup_at_end(), and save().

◆ save_cyborg()

void game::save_cyborg ( item cyborg,
const tripoint couch_pos,
player installer 
)

Turns Broken Cyborg monster into Cyborg NPC via surgery.

Definition at line 4916 of file game.cpp.

4917{
4918 int assist_bonus = installer.get_effect_int( effect_assisted );
4919
4920 float adjusted_skill = installer.bionics_adjusted_skill( skill_firstaid,
4923 -1 );
4924
4925 int damage = cyborg->damage();
4926 int dmg_lvl = cyborg->damage_level( 4 );
4927 int difficulty = 12;
4928
4929 if( damage != 0 ) {
4930
4931 popup( _( "WARNING: Patient's body is damaged. Difficulty of the procedure is increased by %s." ),
4932 dmg_lvl );
4933
4934 // Damage of the cyborg increases difficulty
4935 difficulty += dmg_lvl;
4936 }
4937
4938 int chance_of_success = bionic_manip_cos( adjusted_skill + assist_bonus, difficulty );
4939 int success = chance_of_success - rng( 1, 100 );
4940
4941 if( !g->u.query_yn(
4942 _( "WARNING: %i percent chance of SEVERE damage to all body parts! Continue anyway?" ),
4943 100 - static_cast<int>( chance_of_success ) ) ) {
4944 return;
4945 }
4946
4947 if( success > 0 ) {
4948 add_msg( m_good, _( "Successfully removed Personality override." ) );
4949 add_msg( m_bad, _( "Autodoc immediately destroys the CBM upon removal." ) );
4950
4951 delete_cyborg_item( g->m, couch_pos, cyborg );
4952
4953 const string_id<npc_template> npc_cyborg( "cyborg_rescued" );
4954 shared_ptr_fast<npc> tmp = make_shared_fast<npc>();
4955 tmp->load_npc_template( npc_cyborg );
4956 tmp->spawn_at_precise( { get_levx(), get_levy() }, couch_pos );
4958 tmp->hurtall( dmg_lvl * 10, nullptr );
4959 tmp->add_effect( effect_downed, rng( 1_turns, 4_turns ), num_bp, 0, true );
4960 load_npcs();
4961
4962 } else {
4963 const int failure_level = static_cast<int>( std::sqrt( std::abs( success ) * 4.0 * difficulty /
4964 adjusted_skill ) );
4965 const int fail_type = std::min( 5, failure_level );
4966 switch( fail_type ) {
4967 case 1:
4968 case 2:
4969 add_msg( m_info, _( "The removal fails." ) );
4970 add_msg( m_bad, _( "The body is damaged." ) );
4971 cyborg->set_damage( damage + 1000 );
4972 break;
4973 case 3:
4974 case 4:
4975 add_msg( m_info, _( "The removal fails badly." ) );
4976 add_msg( m_bad, _( "The body is badly damaged!" ) );
4977 cyborg->set_damage( damage + 2000 );
4978 break;
4979 case 5:
4980 add_msg( m_info, _( "The removal is a catastrophe." ) );
4981 add_msg( m_bad, _( "The body is destroyed!" ) );
4982 delete_cyborg_item( g->m, couch_pos, cyborg );
4983 break;
4984 default:
4985 break;
4986 }
4987
4988 }
4989
4990}
int bionic_manip_cos(float adjusted_skill, int bionic_difficulty)
Definition: bionics.cpp:1961
float bionics_adjusted_skill(const skill_id &most_important_skill, const skill_id &important_skill, const skill_id &least_important_skill, int skill_level=-1)
Calculate skill for (un)installing bionics.
Definition: bionics.cpp:1918
item & set_damage(int qty)
Filter setting damage constrained by min_damage and max_damage.
Definition: item.cpp:714
int damage_level(int max) const
Scale item damage to the given number of levels.
Definition: item.cpp:701
int damage() const
How much damage has the item sustained?
Definition: item.cpp:696
static const skill_id skill_computer("computer")
static void delete_cyborg_item(map &m, const tripoint &couch_pos, item *cyborg)
Definition: game.cpp:4895
static const efftype_id effect_assisted("assisted")
static const skill_id skill_electronics("electronics")
@ success
Definition: behavior.h:20

References _, add_msg(), bionic_manip_cos(), Character::bionics_adjusted_skill(), item::damage(), item::damage_level(), delete_cyborg_item(), effect_assisted, effect_downed, g, Creature::get_effect_int(), get_levx(), get_levy(), overmapbuffer::insert_npc(), load_npcs(), m_bad, m_good, m_info, num_bp, overmap_buffer, popup(), rng(), item::set_damage(), skill_computer, skill_electronics, skill_firstaid, and behavior::success.

◆ save_factions_missions_npcs()

bool game::save_factions_missions_npcs ( )
private

Definition at line 2664 of file game.cpp.

2665{
2666 std::string masterfile = get_world_base_save_path() + "/" + SAVE_MASTER;
2667 return write_to_file( masterfile, [&]( std::ostream & fout ) {
2668 serialize_master( fout );
2669 }, _( "factions data" ) );
2670}
void serialize_master(std::ostream &fout)
Definition: savegame.cpp:1243

References _, get_world_base_save_path(), SAVE_MASTER(), serialize_master(), and write_to_file().

Referenced by cleanup_at_end(), and save().

◆ save_maps()

bool game::save_maps ( )
private

Definition at line 2678 of file game.cpp.

2679{
2680 try {
2681 m.save();
2682 overmap_buffer.save(); // can throw
2683 MAPBUFFER.save(); // can throw
2684 return true;
2685 } catch( const std::exception &err ) {
2686 popup( _( "Failed to save the maps: %s" ), err.what() );
2687 return false;
2688 }
2689}
void save(bool delete_after_save=false)
Store all submaps in this instance into savefiles.
Definition: mapbuffer.cpp:98

References _, m, MAPBUFFER, overmap_buffer, popup(), map::save(), overmapbuffer::save(), and mapbuffer::save().

Referenced by cleanup_at_end(), and save().

◆ save_player_data()

bool game::save_player_data ( )
private

Definition at line 2691 of file game.cpp.

2692{
2693 const std::string playerfile = get_player_base_save_path();
2694
2695 const bool saved_data = write_to_file( playerfile + SAVE_EXTENSION, [&]( std::ostream & fout ) {
2696 serialize( fout );
2697 }, _( "player data" ) );
2698 const bool saved_map_memory = u.save_map_memory();
2699 const bool saved_log = write_to_file( playerfile + SAVE_EXTENSION_LOG, [&](
2700 std::ostream & fout ) {
2701 fout << memorial().dump();
2702 }, _( "player memorial" ) );
2703#if defined(__ANDROID__)
2704 const bool saved_shortcuts = write_to_file( playerfile + SAVE_EXTENSION_SHORTCUTS, [&](
2705 std::ostream & fout ) {
2706 save_shortcuts( fout );
2707 }, _( "quick shortcuts" ) );
2708#endif
2709 const bool saved_diary = u.get_avatar_diary()->store();
2710 return saved_data && saved_map_memory && saved_log && saved_diary
2711#if defined(__ANDROID__)
2712 && saved_shortcuts
2713#endif
2714 ;
2715}
bool save_map_memory()
Definition: avatar.cpp:132
bool store()
Definition: diary.cpp:760
std::string get_player_base_save_path() const
Base path for saving player data.
Definition: game.cpp:12021
void serialize(std::ostream &fout)
Saving and loading functions.
Definition: savegame.cpp:69
std::string dump() const
Concatenates all of the memorial log entries, delimiting them with newlines, and returns the resultin...

References _, memorial_logger::dump(), avatar::get_avatar_diary(), get_player_base_save_path(), memorial(), SAVE_EXTENSION(), SAVE_EXTENSION_LOG(), SAVE_EXTENSION_SHORTCUTS(), avatar::save_map_memory(), serialize(), diary::store(), u, and write_to_file().

Referenced by save().

◆ serialize()

void game::serialize ( std::ostream &  fout)

Saving and loading functions.

Definition at line 69 of file savegame.cpp.

70{
71 /*
72 * Format version 12: Fully json, save the header. Weather and memorial exist elsewhere.
73 * To prevent (or encourage) confusion, there is no version 8. (cata 0.8 uses v7)
74 */
75 // Header
76 fout << "# version " << savegame_version << std::endl;
77
78 JsonOut json( fout, true ); // pretty-print
79
80 json.start_object();
81 // basic game state information.
82 json.member( "turn", calendar::turn );
84 json.member( "calendar_start", calendar_config._start_of_cataclysm );
85 json.member( "game_start", calendar_config._start_of_game );
86 json.member( "initial_season", static_cast<int>( calendar_config._initial_season ) );
87 json.member( "auto_travel_mode", auto_travel_mode );
88 json.member( "run_mode", static_cast<int>( safe_mode ) );
89 json.member( "mostseen", mostseen );
90 // current map coordinates
91 tripoint pos_sm = m.get_abs_sub();
92 const point pos_om = sm_to_om_remain( pos_sm.x, pos_sm.y );
93 json.member( "levx", pos_sm.x );
94 json.member( "levy", pos_sm.y );
95 json.member( "levz", pos_sm.z );
96 json.member( "om_x", pos_om.x );
97 json.member( "om_y", pos_om.y );
98
99 json.member( "grscent", scent.serialize() );
100 json.member( "typescent", scent.serialize( true ) );
101
102 // Then each monster
103 json.member( "active_monsters", *critter_tracker );
104 json.member( "stair_monsters", coming_to_stairs );
105
106 // save stats.
107 json.member( "kill_tracker", *kill_tracker_ptr );
108 json.member( "stats_tracker", *stats_tracker_ptr );
109 json.member( "achievements_tracker", *achievements_tracker_ptr );
110
111 json.member( "token_provider", *token_provider_ptr );
112
113 json.member( "player", u );
114 Messages::serialize( json );
115
116 json.end_object();
117}
A class that keeps time data other than current time.
Definition: calendar.h:530
season_type _initial_season
Definition: calendar.h:534
time_point _start_of_game
Definition: calendar.h:533
time_point _start_of_cataclysm
Definition: calendar.h:532
pimpl< drop_token_provider > token_provider_ptr
Definition: game.h:974
std::string serialize(bool is_type=false) const
Definition: savegame.cpp:119
point sm_to_om_remain(int &x, int &y)
void serialize(JsonOut &json)
Definition: messages.cpp:321
calendar_config config
const int savegame_version
Definition: savegame.cpp:57

References calendar_config::_initial_season, calendar_config::_start_of_cataclysm, calendar_config::_start_of_game, achievements_tracker_ptr, auto_travel_mode, coming_to_stairs, calendar::config, critter_tracker, JsonOut::end_object(), map::get_abs_sub(), kill_tracker_ptr, m, JsonOut::member(), mostseen, safe_mode, savegame_version, scent, scent_map::serialize(), Messages::serialize(), sm_to_om_remain(), JsonOut::start_object(), stats_tracker_ptr, token_provider_ptr, calendar::turn, u, point::x, tripoint::x, point::y, tripoint::y, and tripoint::z.

Referenced by save_player_data().

◆ serialize_master()

void game::serialize_master ( std::ostream &  fout)
private

Definition at line 1243 of file savegame.cpp.

1244{
1245 fout << "# version " << savegame_version << std::endl;
1246 try {
1247 JsonOut json( fout, true ); // pretty-print
1248 json.start_object();
1249
1250 json.member( "next_mission_id", next_mission_id );
1251 json.member( "next_npc_id", next_npc_id );
1252
1253 json.member( "active_missions" );
1254 mission::serialize_all( json );
1255
1256 json.member( "factions", *faction_manager_ptr );
1257 json.member( "seed", seed );
1258
1259 json.member( "weather" );
1260 json.start_object();
1261 json.member( "lightning", get_weather().lightning_active );
1262 json.end_object();
1263
1264 json.end_object();
1265 } catch( const JsonError &e ) {
1266 debugmsg( "error saving to %s: %s", SAVE_MASTER, e.c_str() );
1267 }
1268}
Definition: json.h:51
const char * c_str() const noexcept
Definition: json.h:54
static void serialize_all(JsonOut &json)
Definition: savegame.cpp:1234

References JsonError::c_str(), debugmsg, JsonOut::end_object(), faction_manager_ptr, get_weather, JsonOut::member(), next_mission_id, next_npc_id, SAVE_MASTER(), savegame_version, seed, mission::serialize_all(), and JsonOut::start_object().

Referenced by save_factions_missions_npcs().

◆ set_critter_died()

void game::set_critter_died ( )

If invoked, dead will be cleaned this turn.

Definition at line 1798 of file game.cpp.

1799{
1800 critter_died = true;
1801}

References critter_died.

◆ set_driving_view_offset()

void game::set_driving_view_offset ( point  p)

Definition at line 1608 of file game.cpp.

1609{
1610 // remove the previous driving offset,
1611 // store the new offset and apply the new offset.
1618}

References driving_view_offset, u, player::view_offset, point::x, tripoint::x, point::y, and tripoint::y.

Referenced by calc_driving_offset(), and cleanup_at_end().

◆ set_npcs_dirty()

void game::set_npcs_dirty ( )

If invoked, NPCs will be reloaded before next turn.

Definition at line 1793 of file game.cpp.

1794{
1795 npcs_dirty = true;
1796}

References npcs_dirty.

◆ set_safe_mode()

void game::set_safe_mode ( safe_mode_type  mode)

Definition at line 8627 of file game.cpp.

8628{
8629 safe_mode = mode;
8631}

References safe_mode, and safe_mode_warning_logged.

Referenced by handle_action(), and mon_info_update().

◆ set_zoom()

void game::set_zoom ( int  level)

Definition at line 7082 of file game.cpp.

7083{
7084#if defined(TILES)
7085 if( tileset_zoom != level ) {
7086 tileset_zoom = level;
7087 rescale_tileset( tileset_zoom );
7088 }
7089#else
7090 static_cast<void>( level );
7091#endif // TILES
7092}

References tileset_zoom.

Referenced by look_around().

◆ setremoteveh()

void game::setremoteveh ( vehicle veh)

Sets the current remotely controlled vehicle.

Definition at line 2281 of file game.cpp.

2282{
2284 remoteveh_cache = veh;
2285 if( veh != nullptr && !u.has_active_bionic( bio_remote ) &&
2287 debugmsg( "Tried to set remote vehicle without bio_remote or remotevehcontrol" );
2288 veh = nullptr;
2289 }
2290
2291 if( veh == nullptr ) {
2292 u.remove_value( "remote_controlling_vehicle" );
2293 return;
2294 }
2295
2296 std::stringstream remote_veh_string;
2297 const tripoint vehpos = veh->global_pos3();
2298 remote_veh_string << vehpos.x << ' ' << vehpos.y << ' ' << vehpos.z;
2299 u.set_value( "remote_controlling_vehicle", remote_veh_string.str() );
2300}
void remove_value(const std::string &key)
Definition: creature.cpp:1357

References bio_remote, debugmsg, vehicle::global_pos3(), Character::has_active_bionic(), Character::has_active_item(), itype_remotevehcontrol, remoteveh_cache, remoteveh_cache_time, Creature::remove_value(), Creature::set_value(), calendar::turn, u, tripoint::x, tripoint::y, and tripoint::z.

◆ setup()

void game::setup ( )

Definition at line 477 of file game.cpp.

478{
479 loading_ui ui( true );
480
482
483 if( get_option<bool>( "ELEVATED_BRIDGES" ) && !get_option<bool>( "ZLEVELS" ) ) {
484 debugmsg( "\"Elevated bridges\" mod requires z-levels to be ENABLED to work properly!" );
485 }
486
487 m = map( get_option<bool>( "ZLEVELS" ) );
488
490 next_mission_id = 1;
491 new_game = true;
492 uquit = QUIT_NO; // We haven't quit the game
493 bVMonsterLookFire = true;
494
495 // invalidate calendar caches in case we were previously playing
496 // a different world
497 calendar::set_eternal_season( ::get_option<bool>( "ETERNAL_SEASON" ) );
498 calendar::set_season_length( ::get_option<int>( "SEASON_LENGTH" ) );
499
502
503 turnssincelastmon = 0; //Auto safe mode init
504
507 coming_to_stairs.clear();
508 active_npc.clear();
509 faction_manager_ptr->clear();
514
515 SCT.vSCT.clear(); //Delete pending messages
516
517 stats().clear();
518 // reset kill counts
519 kill_tracker_ptr->clear();
521 // reset follower list
522 follower_ids.clear();
523 scent.reset();
524
526 remoteveh_cache = nullptr;
527
528 token_provider_ptr->clear();
529 // back to menu for save loading, new game etc
530}
void clear_zombies()
Redirects to the creature_tracker clear() function.
Definition: game.cpp:4730
static void clear_all()
Remove all active missions, used to cleanup on exit and before reloading a new game.
Definition: mission.cpp:127
void reset()
Definition: scent_map.cpp:51
static const string_id< weather_type > & NULL_ID()
Returns a null id whose string_id<T>::is_null() must always return true.
void clear_messages()
Definition: messages.cpp:351
void load_world_modfiles(loading_ui &ui, const std::string &artifacts_file)
Load & finalize modlist needed for the current world.
Definition: init.cpp:874
void reset_sounds()
Definition: sounds.cpp:565

References achievements_tracker_ptr, active_npc, calendar::before_time_starts, bVMonsterLookFire, character_id, explosion_handler::explosion_queue::clear(), stats_tracker::clear(), mission::clear_all(), Messages::clear_messages(), clear_zombies(), coming_to_stairs, debugmsg, faction_manager_ptr, follower_ids, explosion_handler::get_explosion_queue(), get_weather, get_world_base_save_path(), kill_tracker_ptr, init::load_world_modfiles(), m, new_game, next_mission_id, next_npc_id, weather_manager::nextweather, string_id< weather_type >::NULL_ID(), QUIT_NO, remoteveh_cache, remoteveh_cache_time, scent_map::reset(), sounds::reset_sounds(), SAVE_ARTIFACTS(), scent, SCT, calendar::set_eternal_season(), calendar::set_season_length(), stats(), timed_events, token_provider_ptr, turnssincelastmon, uquit, scrollingcombattext::vSCT, and weather_manager::weather_id.

Referenced by butcher_submenu(), and quickload().

◆ shared_from()

template<typename T >
template shared_ptr_fast< npc > game::shared_from< npc > ( const T &  critter)

Returns a shared pointer to the given critter (which can be of any of the subclasses of Creature).

The function may return an empty pointer if the given critter is not stored anywhere (e.g. it was allocated on the stack, not stored in the critter_tracker nor in active_npc nor is it u).

Definition at line 4583 of file game.cpp.

4584{
4585 if( static_cast<const Creature *>( &critter ) == static_cast<const Creature *>( &u ) ) {
4586 // u is not stored in a shared_ptr, but it won't go out of scope anyway
4587 return std::dynamic_pointer_cast<T>( u_shared_ptr );
4588 }
4589 if( critter.is_monster() ) {
4590 if( const shared_ptr_fast<monster> mon_ptr = critter_tracker->find( critter.pos() ) ) {
4591 if( static_cast<const Creature *>( mon_ptr.get() ) == static_cast<const Creature *>( &critter ) ) {
4592 return std::dynamic_pointer_cast<T>( mon_ptr );
4593 }
4594 }
4595 }
4596 if( critter.is_npc() ) {
4597 for( auto &cur_npc : active_npc ) {
4598 if( static_cast<const Creature *>( cur_npc.get() ) == static_cast<const Creature *>( &critter ) ) {
4599 return std::dynamic_pointer_cast<T>( cur_npc );
4600 }
4601 }
4602 }
4603 return nullptr;
4604}

References active_npc, critter_tracker, u, and u_shared_ptr.

Referenced by list_monsters(), mon_info_update(), and validate_mounted_npcs().

◆ shift_destination_preview()

void game::shift_destination_preview ( point  delta)

Definition at line 12034 of file game.cpp.

12035{
12036 for( tripoint &p : destination_preview ) {
12037 p += delta;
12038 }
12039}

References destination_preview.

◆ shift_monsters()

void game::shift_monsters ( const tripoint shift)
private

Shift all active monsters, the shift vector is the number of shifted submaps.

Monsters that are outside of the reality bubble after shifting are despawned. Note on z-levels: this works with vertical shifts, but currently all monsters are despawned upon a vertical shift.

Definition at line 11023 of file game.cpp.

11024{
11025 // If either shift argument is non-zero, we're shifting.
11026 if( shift == tripoint_zero ) {
11027 return;
11028 }
11029 for( monster &critter : all_monsters() ) {
11030 if( shift.xy() != point_zero ) {
11031 critter.shift( shift.xy() );
11032 }
11033
11034 if( m.inbounds( critter.pos() ) && ( shift.z == 0 || m.has_zlevels() ) ) {
11035 // We're inbounds, so don't despawn after all.
11036 // No need to shift Z-coordinates, they are absolute
11037 continue;
11038 }
11039 // Either a vertical shift or the critter is now outside of the reality bubble,
11040 // anyway: it must be saved and removed.
11041 despawn_monster( critter );
11042 }
11043 // The order in which zombies are shifted may cause zombies to briefly exist on
11044 // the same square. This messes up the mon_at cache, so we need to rebuild it.
11045 critter_tracker->rebuild_cache();
11046}

References all_monsters(), critter_tracker, despawn_monster(), map::has_zlevels(), map::inbounds(), m, point_zero, tripoint_zero, tripoint::xy(), and tripoint::z.

Referenced by update_map(), vertical_move(), and vertical_shift().

◆ slip_down()

bool game::slip_down ( )

Checks if player is able to successfully climb to/from some terrain and not slip down.

Returns
whether player has slipped down
Dexterity decreases chances of slipping while climbing

Definition at line 12041 of file game.cpp.

12042{
12043 ///\EFFECT_DEX decreases chances of slipping while climbing
12044 int climb = u.dex_cur;
12045 if( u.has_trait( trait_BADKNEES ) ) {
12046 climb = climb / 2;
12047 }
12048 if( one_in( climb ) ) {
12049 add_msg( m_bad, _( "You slip while climbing and fall down again." ) );
12050 if( climb <= 1 ) {
12051 add_msg( m_bad, _( "Climbing is impossible in your current state." ) );
12052 }
12053 return true;
12054 }
12055 return false;
12056}
static const trait_id trait_BADKNEES("BADKNEES")

References _, add_msg(), Character::dex_cur, Character::has_trait(), m_bad, one_in(), trait_BADKNEES, and u.

◆ spawn_hallucination()

bool game::spawn_hallucination ( const tripoint p)

Spawns a hallucination at a determined position.

Attempts to spawn a hallucination at given location.

Returns false if the hallucination couldn't be spawned for whatever reason, such as a monster already in the target square.

Returns
Whether or not a hallucination was successfully spawned.

Definition at line 4741 of file game.cpp.

4742{
4743 if( one_in( 100 ) ) {
4744 shared_ptr_fast<npc> tmp = make_shared_fast<npc>();
4745 tmp->randomize( NC_HALLU );
4746 tmp->spawn_at_precise( { get_levx(), get_levy() }, p );
4747 if( !critter_at( p, true ) ) {
4749 load_npcs();
4750 return true;
4751 } else {
4752 return false;
4753 }
4754 }
4755
4757 const shared_ptr_fast<monster> phantasm = make_shared_fast<monster>( mt );
4758 phantasm->hallucination = true;
4759 phantasm->spawn( p );
4760
4761 //Don't attempt to place phantasms inside of other creatures
4762 if( !critter_at( phantasm->pos(), true ) ) {
4763 return critter_tracker->add( phantasm );
4764 } else {
4765 return false;
4766 }
4767}
mtype_id get_valid_hallucination() const
static MonsterGenerator & generator()
npc_class_id NC_HALLU("NC_HALLU")

References critter_at(), critter_tracker, MonsterGenerator::generator(), get_levx(), get_levy(), MonsterGenerator::get_valid_hallucination(), overmapbuffer::insert_npc(), load_npcs(), NC_HALLU, one_in(), and overmap_buffer.

◆ spell_events_subscriber()

spell_events & game::spell_events_subscriber ( )

Definition at line 2732 of file game.cpp.

2733{
2734 return *spell_events_ptr;
2735}

References spell_events_ptr.

◆ start_calendar()

void game::start_calendar ( )

Definition at line 11601 of file game.cpp.

11602{
11603 const bool scen_season = scen->has_flag( "SPR_START" ) || scen->has_flag( "SUM_START" ) ||
11604 scen->has_flag( "AUT_START" ) || scen->has_flag( "WIN_START" ) ||
11605 scen->has_flag( "SUM_ADV_START" );
11606
11608 if( scen_season ) {
11609 // Configured starting date overridden by scenario, calendar_config.start is left as Spring 1
11611 get_option<int>( "INITIAL_TIME" );
11612 calendar_config._start_of_game = calendar::turn_zero + 1_hours * get_option<int>( "INITIAL_TIME" );
11613 if( scen->has_flag( "SPR_START" ) ) {
11615 } else if( scen->has_flag( "SUM_START" ) ) {
11618 } else if( scen->has_flag( "AUT_START" ) ) {
11621 } else if( scen->has_flag( "WIN_START" ) ) {
11624 } else if( scen->has_flag( "SUM_ADV_START" ) ) {
11627 } else {
11628 debugmsg( "The Unicorn" );
11629 }
11630 } else {
11631 // No scenario, so use the starting date+time configured in world options
11632 int initial_days = get_option<int>( "INITIAL_DAY" );
11633 if( initial_days == -1 ) {
11634 // 0 - 363 for a 91 day season
11635 initial_days = rng( 0, get_option<int>( "SEASON_LENGTH" ) * 4 - 1 );
11636 }
11638
11639 // Determine the season based off how long the seasons are set to be
11640 // First take the number of season elapsed up to the starting date, then mod by 4 to get the season of the current year
11641 const int season_number = ( initial_days / get_option<int>( "SEASON_LENGTH" ) ) % 4;
11642 if( season_number == 0 ) {
11644 } else if( season_number == 1 ) {
11646 } else if( season_number == 2 ) {
11648 } else {
11650 }
11651
11653 + 1_hours * get_option<int>( "INITIAL_TIME" )
11654 + 1_days * get_option<int>( "SPAWN_DELAY" );
11655 }
11656
11658}
@ WINTER
Definition: calendar.h:21
@ AUTUMN
Definition: calendar.h:20
@ SUMMER
Definition: calendar.h:19
@ SPRING
Definition: calendar.h:18
time_duration season_length() const
Definition: calendar.h:569
const scenario * scen
Definition: game.h:981
bool has_flag(const std::string &flag) const
Such as a seasonal start, fiery start, surrounded start, etc.
Definition: scenario.cpp:439

References calendar_config::_initial_season, calendar_config::_start_of_cataclysm, calendar_config::_start_of_game, AUTUMN, calendar::config, debugmsg, scenario::has_flag(), rng(), scen, calendar_config::season_length(), SPRING, SUMMER, calendar::turn, calendar::turn_zero, and WINTER.

Referenced by start_game().

◆ start_game()

bool game::start_game ( )
private

Definition at line 556 of file game.cpp.

557{
558 if( !gamemode ) {
559 gamemode = std::make_unique<special_game>();
560 }
561
562 seed = rng_bits();
563 new_game = true;
566 safe_mode = ( get_option<bool>( "SAFEMODE" ) ? SAFE_MODE_ON : SAFE_MODE_OFF );
567 mostseen = 0; // ...and mostseen is 0, we haven't seen any monsters yet.
570
572
575 popup.message( "%s", _( "Please wait as we build your world" ) );
578
579 load_master();
580 u.setID( assign_npc_id() ); // should be as soon as possible, but *after* load_master
581
585 do {
586 omtstart = start_loc.find_player_initial_location();
587 if( omtstart == overmap::invalid_tripoint ) {
588 if( query_yn(
589 _( "Try again?\n\nIt may require several attempts until the game finds a valid starting location." ) ) ) {
592 } else {
593 return false;
594 }
595 }
596 } while( omtstart == overmap::invalid_tripoint );
597
598 start_loc.prepare_map( omtstart );
599
600 // Place vehicles spawned by scenario or profession, has to be placed very early to avoid bugs.
601 if( u.starting_vehicle &&
602 !place_vehicle_nearby( u.starting_vehicle, omtstart.xy(), 0, 30,
603 std::vector<std::string> {} ) ) {
604 debugmsg( "could not place starting vehicle" );
605 }
606
607 if( scen->has_map_extra() ) {
608 // Map extras can add monster spawn points and similar and should be done before the main
609 // map is loaded.
610 start_loc.add_map_extra( omtstart, scen->get_map_extra() );
611 }
612
613 // TODO: fix point types
614 tripoint lev = project_to<coords::sm>( omtstart ).raw();
615 // The player is centered in the map, but lev[xyz] refers to the top left point of the map
616 lev.x -= HALF_MAPSIZE;
617 lev.y -= HALF_MAPSIZE;
618 load_map( lev, /*pump_events=*/true );
619
622 // Do this after the map cache has been built!
623 start_loc.place_player( u );
624 // ...but then rebuild it, because we want visibility cache to avoid spawning monsters in sight
627 // Start the overmap with out immediate neighborhood visible, this needs to be after place_player
629 get_option<int>( "DISTANCE_INITIAL_VISIBILITY" ), 0 );
630
631 u.moves = 0;
632 if( u.has_trait( trait_PROF_FERAL ) ) {
634 }
635 u.process_turn(); // process_turn adds the initial move points
639 u.next_climate_control_check = calendar::before_time_starts; // Force recheck at startup
641
642 //Reset character safe mode/pickup rules
647
648 //Put some NPCs in there!
649 if( get_option<std::string>( "STARTING_NPC" ) == "always" ||
650 ( get_option<std::string>( "STARTING_NPC" ) == "scenario" &&
651 !g->scen->has_flag( "LONE_START" ) ) ) {
653 }
654 //Load NPCs. Set nearby npcs to active.
655 load_npcs();
656 // Spawn the monsters
657 const bool spawn_near =
658 get_option<bool>( "BLACK_ROAD" ) || g->scen->has_flag( "SUR_START" );
659 // Surrounded start ones
660 if( spawn_near ) {
661 start_loc.surround_with_monsters( omtstart, mongroup_id( "GROUP_ZOMBIE" ), 70 );
662 }
663
664 m.spawn_monsters( !spawn_near ); // Static monsters
665
666 // Make sure that no monsters are near the player
667 // This can happen in lab starts
668 if( !spawn_near ) {
669 for( monster &critter : all_monsters() ) {
670 if( rl_dist( critter.pos(), u.pos() ) <= 5 ||
671 m.clear_path( critter.pos(), u.pos(), 40, 1, 100 ) ) {
672 remove_zombie( critter );
673 }
674 }
675 }
676
677 //Create mutation_category_level
679 //Calculate mutation drench protection stats
682 if( scen->has_flag( "FIRE_START" ) ) {
683 start_loc.burn( omtstart, 3, 3 );
684 }
685 if( scen->has_flag( "INFECTED" ) ) {
687 }
688 if( scen->has_flag( "BAD_DAY" ) ) {
689 u.add_effect( effect_flu, 1000_minutes );
690 u.add_effect( effect_drunk, 270_minutes );
691 u.add_morale( MORALE_FEELING_BAD, -100, -100, 50_minutes, 50_minutes );
692 }
693 if( scen->has_flag( "HELI_CRASH" ) ) {
694 start_loc.handle_heli_crash( u );
695 bool success = false;
696 for( auto v : m.get_vehicles() ) {
697 std::string name = v.v->type.str();
698 std::string search = std::string( "helicopter" );
699 if( name.find( search ) != std::string::npos ) {
700 for( const vpart_reference &vp : v.v->get_any_parts( VPFLAG_CONTROLS ) ) {
701 const tripoint pos = vp.pos();
702 u.setpos( pos );
703
704 // Delete the items that would have spawned here from a "corpse"
705 for( auto sp : v.v->parts_at_relative( vp.mount(), true ) ) {
706 vehicle_stack here = v.v->get_items( sp );
707
708 for( auto iter = here.begin(); iter != here.end(); ) {
709 iter = here.erase( iter );
710 }
711 }
712
713 auto mons = critter_tracker->find( pos );
714 if( mons != nullptr ) {
715 critter_tracker->remove( *mons );
716 }
717
718 success = true;
719 break;
720 }
721 if( success ) {
722 v.v->name = "Bird Wreckage";
723 break;
724 }
725 }
726 }
727 }
728 if( scen->has_flag( "BORDERED" ) ) {
729 overmap &starting_om = get_cur_om();
730 for( int z = -OVERMAP_DEPTH; z <= OVERMAP_HEIGHT; z++ ) {
731 starting_om.place_special_forced( overmap_special_id( "world" ), { 0, 0, z },
733 }
734
735 }
736 for( auto &e : u.inv_dump() ) {
737 e->set_owner( g->u );
738 }
739 // Now that we're done handling coordinates, ensure the player's submap is in the center of the map
740 update_map( u );
741 // Profession pets
742 for( const mtype_id &elem : u.starting_pets ) {
743 if( monster *const mon = place_critter_around( elem, u.pos(), 5 ) ) {
744 mon->friendly = -1;
745 mon->add_effect( effect_pet, 1_turns, num_bp );
746 } else {
747 add_msg( m_debug, "cannot place starting pet, no space!" );
748 }
749 }
750 // Assign all of this scenario's missions to the player.
751 for( const mission_type_id &m : scen->missions() ) {
752 const auto mission = mission::reserve_new( m, character_id() );
753 mission->assign( u );
754 }
755 g->events().send<event_type::game_start>( u.getID() );
756 for( Skill &elem : Skill::skills ) {
757 int level = u.get_skill_level_object( elem.ident() ).level();
758 if( level > 0 ) {
759 g->events().send<event_type::gains_skill_level>( u.getID(), elem.ident(), level );
760 }
761 }
762 return true;
763}
body_part random_body_part(bool main_parts_only)
Returns a random body_part token.
Definition: bodypart.cpp:366
bool last_climate_control_ret
Definition: character.h:2294
SkillLevel & get_skill_level_object(const skill_id &ident)
Definition: character.cpp:3335
void drench_mut_calc()
Recalculates mutation drench protection for all bodyparts (ignored/good/neutral stats)
Definition: character.cpp:7799
void set_stamina(int new_stamina)
Definition: character.cpp:7090
time_point next_climate_control_check
Definition: character.h:2293
int get_stamina_max() const
Definition: character.cpp:7079
void set_highest_cat_level()
Recalculates mutation_category_level[] values for the player.
Definition: character.cpp:7776
void default_initialize()
Perform default initialization.
Definition: auto_note.cpp:101
void start_calendar()
Definition: game.cpp:11601
void create_starting_npcs()
Definition: game.cpp:891
overmap & get_cur_om() const
The overmap which contains the center submap of the reality bubble.
Definition: game.cpp:11901
vehicle * place_vehicle_nearby(const vproto_id &id, const point_abs_omt &origin, int min_distance, int max_distance, const std::vector< std::string > &omt_search_types={})
Definition: game.cpp:765
bool clear_path(const tripoint &f, const tripoint &t, int range, int cost_min, int cost_max) const
Check whether there's a direct line of sight between F and T with the additional movecost restraints.
Definition: map.cpp:6506
static mission * reserve_new(const mission_type_id &type, const character_id &npc_id)
Create a new mission of the given type and assign it to the given npc.
Definition: mission.cpp:64
void assign(avatar &u)
Assigns the mission to the player.
Definition: mission.cpp:210
void place_special_forced(const overmap_special_id &special_id, const tripoint_om_omt &p, om_direction::type dir)
Definition: overmap.cpp:2164
bool reveal(const point_abs_omt &center, int radius, int z)
Mark a square area around center on Z-level z as seen.
bool random_start_location
Definition: player.h:238
vproto_id starting_vehicle
Definition: player.h:250
std::vector< mtype_id > starting_pets
Definition: player.h:251
start_location_id start_location
Definition: player.h:239
void clear_character_rules()
bool has_map_extra() const
Definition: scenario.cpp:454
const std::string & get_map_extra() const
Definition: scenario.cpp:458
const std::vector< mission_type_id > & missions() const
Definition: scenario.cpp:462
start_location_id random_start_location() const
Definition: scenario.cpp:232
void burn(const tripoint_abs_omt &omtstart, size_t count, int rad) const
Burn random terrain / furniture with FLAMMABLE or FLAMMABLE_ASH tag.
void surround_with_monsters(const tripoint_abs_omt &omtstart, const mongroup_id &type, float expected_points) const
Adds surround start monsters.
void prepare_map(const tripoint_abs_omt &omtstart) const
Initialize the map at players start location using prepare_map.
void place_player(player &u) const
Place the player somewhere in the reality bubble (g->m).
void handle_heli_crash(player &u) const
tripoint_abs_omt find_player_initial_location() const
Find a suitable start location on the overmap.
void add_map_extra(const tripoint_abs_omt &omtstart, const std::string &map_extra) const
Adds a map extra, see map_extras.h and map_extras.cpp.
const T & obj() const
Returns the actual object this id refers to.
Definition: achievement.cpp:60
iterator erase(const_iterator it) override
Definition: vehicle.cpp:231
static const efftype_id effect_drunk("drunk")
static const efftype_id effect_infected("infected")
static const trait_id trait_PROF_FERAL("PROF_FERAL")
static const efftype_id effect_accumulated_mutagen("accumulated_mutagen")
static const efftype_id effect_flu("flu")
static const efftype_id effect_feral_killed_recently("feral_killed_recently")
static constexpr int SPRING_TEMPERATURE
Base starting spring temperature in F used for climate, weather and temperature calculation.
void update_weather()
Definition: weather.cpp:1056
const morale_type MORALE_FEELING_BAD("morale_feeling_bad")
static bool search(const ui_adaptor &om_ui, tripoint_abs_omt &curs, const tripoint_abs_omt &orig)
unsigned int rng_bits()
Definition: rng.cpp:12
string_id< overmap_special > overmap_special_id
Definition: type_id.h:137
string_id< MonsterGroup > mongroup_id
Definition: type_id.h:108
@ VPFLAG_CONTROLS
Definition: veh_type.h:41

References _, Creature::add_effect(), start_location::add_map_extra(), Character::add_morale(), add_msg(), all_monsters(), mission::assign(), assign_npc_id(), calendar::before_time_starts, item_stack::begin(), map::build_map_cache(), start_location::burn(), character_id, auto_notes::auto_note_settings::clear(), mapbuffer::clear(), overmapbuffer::clear(), auto_pickup::player_settings::clear_character_rules(), safemode::clear_character_rules(), map::clear_path(), create_starting_npcs(), critter_tracker, debugmsg, auto_notes::auto_note_settings::default_initialize(), Character::drench_mut_calc(), effect_accumulated_mutagen, effect_drunk, effect_feral_killed_recently, effect_flu, effect_infected, effect_pet, item_stack::end(), vehicle_stack::erase(), start_location::find_player_initial_location(), g, gains_skill_level, game_start, gamemode, get_auto_notes_settings(), get_auto_pickup(), get_cur_om(), get_distraction_manager(), get_levz(), scenario::get_map_extra(), get_safemode(), Character::get_skill_level_object(), Character::get_stamina_max(), map::get_vehicles(), get_weather, Character::getID(), Character::global_omt_location(), HALF_MAPSIZE, start_location::handle_heli_crash(), scenario::has_flag(), scenario::has_map_extra(), Character::has_trait(), init_autosave(), Character::inv_dump(), overmap::invalid_tripoint, map::invalidate_map_cache(), Character::last_climate_control_ret, distraction_manager::distraction_manager_gui::load(), safemode::load_global(), load_map(), load_master(), load_npcs(), m, m_debug, MAPBUFFER, scenario::missions(), MORALE_FEELING_BAD, mostseen, Creature::moves, om_direction::name(), new_game, Character::next_climate_control_check, weather_manager::nextweather, om_direction::north, num_bp, string_id< T >::obj(), overmap_buffer, OVERMAP_DEPTH, OVERMAP_HEIGHT, place_critter_around(), start_location::place_player(), overmap::place_special_forced(), place_vehicle_nearby(), popup(), Character::pos(), start_location::prepare_map(), Character::process_turn(), query_yn(), random_body_part(), player::random_start_location, scenario::random_start_location(), ui_manager::redraw(), refresh_display(), remove_zombie(), mission::reserve_new(), overmapbuffer::reveal(), rl_dist(), rng_bits(), safe_mode, SAFE_MODE_OFF, SAFE_MODE_ON, scen, overmap_ui::search(), seed, Character::set_highest_cat_level(), Character::set_stamina(), Character::setID(), Character::setpos(), Skill::skills, map::spawn_monsters(), SPRING_TEMPERATURE, start_calendar(), player::start_location, player::starting_pets, player::starting_vehicle, behavior::success, start_location::surround_with_monsters(), weather_manager::temperature, trait_PROF_FERAL, calendar::turn, u, update_map(), weather_manager::update_weather(), VPFLAG_CONTROLS, tripoint::x, coords::coord_point< Point, Origin, Scale >::xy(), and tripoint::y.

◆ start_hauling()

void game::start_hauling ( const tripoint pos)

Definition at line 10386 of file game.cpp.

10387{
10388 // Find target items and quantities thereof for the new activity
10389 std::vector<item_location> target_items;
10390 std::vector<int> quantities;
10391
10392 map_stack items = m.i_at( pos );
10393 for( item &it : items ) {
10394 // Liquid cannot be picked up
10395 if( it.made_of( LIQUID ) ) {
10396 continue;
10397 }
10398 target_items.emplace_back( map_cursor( pos ), &it );
10399 // Quantity of 0 means move all
10400 quantities.push_back( 0 );
10401 }
10402
10403 if( target_items.empty() ) {
10404 // Nothing to haul
10405 return;
10406 }
10407
10408 // Whether the destination is inside a vehicle (not supported)
10409 const bool to_vehicle = false;
10410 // Destination relative to the player
10411 const tripoint relative_destination{};
10412
10414 target_items,
10415 quantities,
10416 to_vehicle,
10417 relative_destination
10418 ) ) );
10419}

References Character::assign_activity(), map::i_at(), LIQUID, m, and u.

Referenced by vertical_move(), and walk_move().

◆ stats()

stats_tracker & game::stats ( )

Definition at line 2722 of file game.cpp.

2723{
2724 return *stats_tracker_ptr;
2725}

References stats_tracker_ptr.

Referenced by death_screen(), handle_action(), setup(), and win().

◆ swap_critters()

bool game::swap_critters ( Creature a,
Creature b 
)

Swaps positions of two creatures.

Definition at line 4769 of file game.cpp.

4770{
4771 if( &a == &b ) {
4772 // No need to do anything, but print a debugmsg anyway
4773 debugmsg( "Tried to swap %s with itself", a.disp_name() );
4774 return true;
4775 }
4776 if( critter_at( a.pos() ) != &a ) {
4777 debugmsg( "Tried to swap when it would cause a collision between %s and %s.",
4778 b.disp_name(), critter_at( a.pos() )->disp_name() );
4779 return false;
4780 }
4781 if( critter_at( b.pos() ) != &b ) {
4782 debugmsg( "Tried to swap when it would cause a collision between %s and %s.",
4783 a.disp_name(), critter_at( b.pos() )->disp_name() );
4784 return false;
4785 }
4786 // Simplify by "sorting" the arguments
4787 // Only the first argument can be u
4788 // If swapping player/npc with a monster, monster is second
4789 bool a_first = a.is_player() ||
4790 ( a.is_npc() && !b.is_player() );
4791 Creature &first = a_first ? a : b;
4792 Creature &second = a_first ? b : a;
4793 // Possible options:
4794 // both first and second are monsters
4795 // second is a monster, first is a player or an npc
4796 // first is a player, second is an npc
4797 // both first and second are npcs
4798 if( first.is_monster() ) {
4799 monster *m1 = dynamic_cast< monster * >( &first );
4800 monster *m2 = dynamic_cast< monster * >( &second );
4801 if( m1 == nullptr || m2 == nullptr || m1 == m2 ) {
4802 debugmsg( "Couldn't swap two monsters" );
4803 return false;
4804 }
4805
4806 critter_tracker->swap_positions( *m1, *m2 );
4807 return true;
4808 }
4809
4810 player *u_or_npc = dynamic_cast< player * >( &first );
4811 player *other_npc = dynamic_cast< player * >( &second );
4812
4813 if( u_or_npc->in_vehicle ) {
4814 m.unboard_vehicle( u_or_npc->pos() );
4815 }
4816
4817 if( other_npc && other_npc->in_vehicle ) {
4818 m.unboard_vehicle( other_npc->pos() );
4819 }
4820
4821 tripoint temp = second.pos();
4822 second.setpos( first.pos() );
4823
4824 if( first.is_player() ) {
4825 walk_move( temp );
4826 } else {
4827 first.setpos( temp );
4828 if( m.veh_at( u_or_npc->pos() ).part_with_feature( VPFLAG_BOARDABLE, true ) ) {
4829 m.board_vehicle( u_or_npc->pos(), u_or_npc );
4830 }
4831 }
4832
4833 if( other_npc && m.veh_at( other_npc->pos() ).part_with_feature( VPFLAG_BOARDABLE, true ) ) {
4834 m.board_vehicle( other_npc->pos(), other_npc );
4835 }
4836 return true;
4837}
virtual bool is_monster() const
Definition: creature.h:101
virtual bool is_player() const
Definition: creature.h:92
virtual void setpos(const tripoint &pos)=0
bool walk_move(const tripoint &dest, bool via_ramp=false)
Definition: game.cpp:8766
constexpr double a
Definition: magic.cpp:1030
constexpr double b
Definition: magic.cpp:1031
@ VPFLAG_BOARDABLE
Definition: veh_type.h:39

References a, b, map::board_vehicle(), critter_at(), critter_tracker, debugmsg, Character::in_vehicle, Creature::is_monster(), Creature::is_player(), m, optional_vpart_position::part_with_feature(), Creature::pos(), Character::pos(), second, Creature::setpos(), map::unboard_vehicle(), map::veh_at(), VPFLAG_BOARDABLE, and walk_move().

Referenced by npc_menu().

◆ take_screenshot() [1/2]

bool game::take_screenshot ( ) const

Saves a screenshot of the current viewport, as a PNG file.

Filesystem location is derived from the current world and character.

Note
: Only works for SDL/TILES (otherwise the function returns false). A window (more precisely, a viewport) must already exist and the SDL renderer must be valid.
Returns
true if the screenshot generation was successful, false otherwise.

Definition at line 7151 of file game.cpp.

7152{
7153 popup( _( "This binary was not compiled with tiles support." ) );
7154 return false;
7155}

References _, and popup().

Referenced by do_turn().

◆ take_screenshot() [2/2]

bool game::take_screenshot ( const std::string &  file_path) const

Saves a screenshot of the current viewport, as a PNG file, to the given location.

Parameters
file_pathA full path to the file where the screenshot should be saved.
Note
: Only works for SDL/TILES (otherwise the function returns false). A window (more precisely, a viewport) must already exist and the SDL renderer must be valid.
Returns
true if the screenshot generation was successful, false otherwise.

Definition at line 7145 of file game.cpp.

7146{
7147 popup( _( "This binary was not compiled with tiles support." ) );
7148 return false;
7149}

References _, and popup().

◆ temp_exit_fullscreen()

void game::temp_exit_fullscreen ( )

Definition at line 455 of file game.cpp.

456{
457 if( fullscreen ) {
458 was_fullscreen = true;
460 } else {
461 was_fullscreen = false;
462 }
463}

References fullscreen, toggle_fullscreen(), and was_fullscreen.

Referenced by list_items_monsters(), and look_around().

◆ toggle_debug_hour_timer()

void game::toggle_debug_hour_timer ( )

Definition at line 11208 of file game.cpp.

11209{
11211}

References game::debug_hour_timer::toggle().

Referenced by handle_action(), and look_around().

◆ toggle_fullscreen()

void game::toggle_fullscreen ( )

Definition at line 408 of file game.cpp.

409{
410#if !defined(TILES)
413#else
414 toggle_fullscreen_window();
415#endif
416}

References fullscreen, and mark_main_ui_adaptor_resize().

Referenced by handle_action(), reenter_fullscreen(), and temp_exit_fullscreen().

◆ toggle_gate()

void game::toggle_gate ( const tripoint p)

Definition at line 5138 of file game.cpp.

5139{
5140 gates::toggle_gate( p, u );
5141}
void toggle_gate(const tripoint &pos, player &p)
opens/closes the gate via player's activity
Definition: gates.cpp:236

References gates::toggle_gate(), and u.

◆ toggle_pixel_minimap()

void game::toggle_pixel_minimap ( )

Definition at line 418 of file game.cpp.

419{
420#if defined(TILES)
422 clear_window_area( w_pixel_minimap );
423 }
426#endif // TILES
427}

References mark_main_ui_adaptor_resize(), pixel_minimap_option, and w_pixel_minimap.

Referenced by handle_action(), and look_around().

◆ try_get_left_click_action()

bool game::try_get_left_click_action ( action_id act,
const tripoint mouse_target 
)
private

Definition at line 2302 of file game.cpp.

2303{
2304 bool new_destination = true;
2305 if( !destination_preview.empty() ) {
2306 auto &final_destination = destination_preview.back();
2307 if( final_destination.x == mouse_target.x && final_destination.y == mouse_target.y ) {
2308 // Second click
2309 new_destination = false;
2311 destination_preview.clear();
2313 if( act == ACTION_NULL ) {
2314 // Something went wrong
2316 return false;
2317 }
2318 }
2319 }
2320
2321 if( new_destination ) {
2323 u.get_path_avoid() );
2324 return false;
2325 }
2326
2327 return true;
2328}

References act, ACTION_NULL, Character::clear_destination(), destination_preview, Character::get_next_auto_move_direction(), Character::get_path_avoid(), Character::get_pathfinding_settings(), m, Character::pos(), map::route(), Character::set_destination(), u, tripoint::x, and tripoint::y.

Referenced by handle_action().

◆ try_get_right_click_action()

bool game::try_get_right_click_action ( action_id act,
const tripoint mouse_target 
)
private

Definition at line 2330 of file game.cpp.

2331{
2332 const bool cleared_destination = !destination_preview.empty();
2334 destination_preview.clear();
2335
2336 if( cleared_destination ) {
2337 // Produce no-op if auto-move had just been cleared on this action
2338 // e.g. from a previous single left mouse click. This has the effect
2339 // of right-click canceling an auto-move before it is initiated.
2340 return false;
2341 }
2342
2343 const bool is_adjacent = square_dist( mouse_target.xy(), point( u.posx(), u.posy() ) ) <= 1;
2344 const bool is_self = square_dist( mouse_target.xy(), point( u.posx(), u.posy() ) ) <= 0;
2345 if( const monster *const mon = critter_at<monster>( mouse_target ) ) {
2346 if( !u.sees( *mon ) ) {
2347 add_msg( _( "Nothing relevant here." ) );
2348 return false;
2349 }
2350
2351 if( !u.primary_weapon().is_gun() ) {
2352 add_msg( m_info, _( "You are not wielding a ranged weapon." ) );
2353 return false;
2354 }
2355
2356 // TODO: Add weapon range check. This requires weapon to be reloaded.
2357
2358 act = ACTION_FIRE;
2359 } else if( is_adjacent &&
2360 m.close_door( tripoint( mouse_target.xy(), u.posz() ), !m.is_outside( u.pos() ),
2361 true ) ) {
2362 act = ACTION_CLOSE;
2363 } else if( is_self ) {
2365 } else if( is_adjacent ) {
2367 } else {
2368 add_msg( _( "Nothing relevant here." ) );
2369 return false;
2370 }
2371
2372 return true;
2373}
bool close_door(const tripoint &p, bool inside, bool check_only)
Definition: map.cpp:4072
static bool is_adjacent(const monster &z, const Creature &target)

References _, act, ACTION_CLOSE, ACTION_EXAMINE, ACTION_FIRE, ACTION_PICKUP, add_msg(), Character::clear_destination(), map::close_door(), destination_preview, is_adjacent(), item::is_gun(), map::is_outside(), m, m_info, Character::pos(), Character::posx(), Character::posy(), Character::posz(), Character::primary_weapon(), Character::sees(), square_dist(), u, and tripoint::xy().

Referenced by handle_action().

◆ unload_npcs()

void game::unload_npcs ( )
private

Unloads all NPCs.

If you call this you must later call load_npcs, lest caches get rather confused. The tests used to call this a lot when they shouldn't. It is now private to reduce the chance of similar problems in the future.

Definition at line 869 of file game.cpp.

870{
871 for( const auto &npc : active_npc ) {
872 npc->on_unload();
873 }
874
875 active_npc.clear();
876}
void on_unload()
Do some cleanup and caching as npc is being unloaded from map.
Definition: npc.cpp:2684

References active_npc, and npc::on_unload().

Referenced by place_player_overmap(), and reload_npcs().

◆ unserialize()

void game::unserialize ( std::istream &  fin)

Definition at line 167 of file savegame.cpp.

168{
169 chkversion( fin );
170 int tmpturn = 0;
171 int tmpcalstart = 0;
172 int tmprun = 0;
173 tripoint lev;
174 point com;
175 JsonIn jsin( fin );
176 try {
177 JsonObject data = jsin.get_object();
178
179 data.read( "turn", tmpturn );
180 data.read( "calendar_start", tmpcalstart );
182 calendar_config._initial_season = static_cast<season_type>( data.get_int( "initial_season",
183 static_cast<int>( SPRING ) ) );
184 // 0.E stable
185 if( savegame_loading_version < 26 ) {
186 tmpturn *= 6;
187 tmpcalstart *= 6;
188 }
191 tmpcalstart );
192
193 if( !data.read( "game_start", calendar_config._start_of_game ) ) {
195 }
196
197 data.read( "auto_travel_mode", auto_travel_mode );
198 data.read( "run_mode", tmprun );
199 data.read( "mostseen", mostseen );
200 data.read( "levx", lev.x );
201 data.read( "levy", lev.y );
202 data.read( "levz", lev.z );
203 data.read( "om_x", com.x );
204 data.read( "om_y", com.y );
205
206 load_map(
207 tripoint( lev.x + com.x * OMAPX * 2, lev.y + com.y * OMAPY * 2, lev.z ),
208 /*pump_events=*/true
209 );
210
211 safe_mode = static_cast<safe_mode_type>( tmprun );
212 if( get_option<bool>( "SAFEMODE" ) && safe_mode == SAFE_MODE_OFF ) {
214 }
215
216 std::string linebuff;
217 std::string linebuf;
218 if( data.read( "grscent", linebuf ) && data.read( "typescent", linebuff ) ) {
219 scent.deserialize( linebuf );
220 scent.deserialize( linebuff, true );
221 } else {
222 scent.reset();
223 }
224 data.read( "active_monsters", *critter_tracker );
225
226 coming_to_stairs.clear();
227 for( auto elem : data.get_array( "stair_monsters" ) ) {
228 monster stairtmp;
229 elem.read( stairtmp );
230 coming_to_stairs.push_back( stairtmp );
231 }
232
233 if( data.has_object( "kill_tracker" ) ) {
234 data.read( "kill_tracker", *kill_tracker_ptr );
235 } else {
236 // Legacy support for when kills were stored directly in game
237 std::map<mtype_id, int> kills;
238 std::vector<std::string> npc_kills;
239 for( const JsonMember member : data.get_object( "kills" ) ) {
240 kills[mtype_id( member.name() )] = member.get_int();
241 }
242
243 for( const std::string npc_name : data.get_array( "npc_kills" ) ) {
244 npc_kills.push_back( npc_name );
245 }
246
247 kill_tracker_ptr->reset( kills, npc_kills );
248 }
249
250 data.read( "player", u );
252 data.read( "stats_tracker", *stats_tracker_ptr );
253 data.read( "achievements_tracker", *achievements_tracker_ptr );
254 data.read( "token_provider", token_provider_ptr );
256 Messages::deserialize( data );
257
258 } catch( const JsonError &jsonerr ) {
259 debugmsg( "Bad save json\n%s", jsonerr.c_str() );
260 return;
261 }
262}
season_type
Real world seasons.
Definition: calendar.h:17
Represents a member of a JsonObject.
Definition: json.h:1249
JsonObject get_object(const std::string &name) const
Definition: json.cpp:429
bool has_object(const std::string &name) const
Definition: json.cpp:493
JsonArray get_array(const std::string &name) const
Definition: json.cpp:400
int get_int(const std::string &name) const
Definition: json.cpp:350
bool read(const std::string &name, T &t, bool throw_on_error=true) const
Definition: json.h:941
void deserialize(const std::string &data, bool is_type=false)
Definition: savegame.cpp:264
safe_mode_type
Definition: game.h:76
static constexpr int OMAPY
static constexpr int OMAPX
Size of the overmap.
void deserialize(const JsonObject &json)
Definition: messages.cpp:330
std::string member
Definition: mapgen.cpp:410
static void chkversion(std::istream &fin)
Definition: savegame.cpp:148
int savegame_loading_version
Definition: savegame.cpp:64

References calendar_config::_initial_season, calendar_config::_start_of_cataclysm, calendar_config::_start_of_game, achievements_tracker_ptr, auto_travel_mode, JsonError::c_str(), chkversion(), coming_to_stairs, calendar::config, critter_tracker, debugmsg, Messages::deserialize(), scent_map::deserialize(), time_duration::from_turns(), JsonObject::get_array(), JsonObject::get_int(), JsonIn::get_object(), JsonObject::get_object(), JsonObject::has_object(), inp_mngr, kill_tracker_ptr, load_map(), mapgen_defer::member, mostseen, mtype_id, OMAPX, OMAPY, input_manager::pump_events(), JsonObject::read(), scent_map::reset(), safe_mode, SAFE_MODE_OFF, SAFE_MODE_ON, savegame_loading_version, scent, SPRING, stats_tracker_ptr, token_provider_ptr, calendar::turn, calendar::turn_zero, u, point::x, tripoint::x, point::y, tripoint::y, and tripoint::z.

Referenced by load().

◆ unserialize_master()

void game::unserialize_master ( std::istream &  fin)

Definition at line 1193 of file savegame.cpp.

1194{
1196 chkversion( fin );
1197 if( savegame_loading_version < 11 ) {
1198 std::unique_ptr<static_popup>popup = std::make_unique<static_popup>();
1199 popup->message(
1200 _( "Cannot find loader for save data in old version %d, attempting to load as current version %d." ),
1204 }
1205 try {
1206 // single-pass parsing example
1207 JsonIn jsin( fin );
1208 jsin.start_object();
1209 while( !jsin.end_object() ) {
1210 std::string name = jsin.get_member_name();
1211 if( name == "next_mission_id" ) {
1212 next_mission_id = jsin.get_int();
1213 } else if( name == "next_npc_id" ) {
1214 next_npc_id.deserialize( jsin );
1215 } else if( name == "active_missions" ) {
1217 } else if( name == "factions" ) {
1218 jsin.read( *faction_manager_ptr );
1219 } else if( name == "seed" ) {
1220 jsin.read( seed );
1221 } else if( name == "weather" ) {
1222 JsonObject w = jsin.get_object();
1223 w.read( "lightning", get_weather().lightning_active );
1224 } else {
1225 // silently ignore anything else
1226 jsin.skip_value();
1227 }
1228 }
1229 } catch( const JsonError &e ) {
1230 debugmsg( "error loading %s: %s", SAVE_MASTER, e.c_str() );
1231 }
1232}
void deserialize(JsonIn &)
static void unserialize_all(JsonIn &jsin)
Definition: savegame.cpp:1183

References _, JsonError::c_str(), chkversion(), debugmsg, character_id::deserialize(), JsonIn::end_object(), faction_manager_ptr, JsonIn::get_int(), JsonIn::get_member_name(), JsonIn::get_object(), get_weather, om_direction::name(), next_mission_id, next_npc_id, popup(), JsonIn::read(), JsonObject::read(), ui_manager::redraw(), refresh_display(), SAVE_MASTER(), savegame_loading_version, savegame_version, seed, JsonIn::skip_value(), JsonIn::start_object(), and mission::unserialize_all().

Referenced by load_master().

◆ update_map() [1/2]

point game::update_map ( int &  x,
int &  y 
)

Definition at line 10654 of file game.cpp.

10655{
10656 point shift;
10657
10658 while( x < HALF_MAPSIZE_X ) {
10659 x += SEEX;
10660 shift.x--;
10661 }
10662 while( x >= HALF_MAPSIZE_X + SEEX ) {
10663 x -= SEEX;
10664 shift.x++;
10665 }
10666 while( y < HALF_MAPSIZE_Y ) {
10667 y += SEEY;
10668 shift.y--;
10669 }
10670 while( y >= HALF_MAPSIZE_Y + SEEY ) {
10671 y -= SEEY;
10672 shift.y++;
10673 }
10674
10675 if( shift == point_zero ) {
10676 // adjust player position
10677 u.setpos( tripoint( x, y, get_levz() ) );
10678 // Update what parts of the world map we can see
10679 // We need this call because even if the map hasn't shifted we may have changed z-level and can now see farther
10680 // TODO: only make this call if we changed z-level
10682 // Not actually shifting the submaps, all the stuff below would do nothing
10683 return point_zero;
10684 }
10685
10686 // this handles loading/unloading submaps that have scrolled on or off the viewport
10687 // NOLINTNEXTLINE(cata-use-named-point-constants)
10688 inclusive_rectangle<point> size_1( point( -1, -1 ), point( 1, 1 ) );
10689 point remaining_shift = shift;
10690 while( remaining_shift != point_zero ) {
10691 point this_shift = clamp( remaining_shift, size_1 );
10692 m.shift( this_shift );
10693 remaining_shift -= this_shift;
10694 }
10695
10696 grid_tracker_ptr->load( m );
10697
10698 // Shift monsters
10699 shift_monsters( tripoint( shift, 0 ) );
10700 const point shift_ms = sm_to_ms_copy( shift );
10701 u.shift_destination( -shift_ms );
10702
10703 // Shift NPCs
10704 for( auto it = active_npc.begin(); it != active_npc.end(); ) {
10705 ( *it )->shift( shift );
10706 if( ( *it )->posx() < 0 - SEEX * 2 || ( *it )->posy() < 0 - SEEX * 2 ||
10707 ( *it )->posx() > SEEX * ( MAPSIZE + 2 ) || ( *it )->posy() > SEEY * ( MAPSIZE + 2 ) ) {
10708 //Remove the npc from the active list. It remains in the overmap list.
10709 ( *it )->on_unload();
10710 it = active_npc.erase( it );
10711 } else {
10712 it++;
10713 }
10714 }
10715
10716 scent.shift( shift_ms );
10717
10718 // Also ensure the player is on current z-level
10719 // get_levz() should later be removed, when there is no longer such a thing
10720 // as "current z-level"
10721 u.setpos( tripoint( x, y, get_levz() ) );
10722
10723 // Only do the loading after all coordinates have been shifted.
10724
10725 // Check for overmap saved npcs that should now come into view.
10726 // Put those in the active list.
10727 load_npcs();
10728
10729 // Make sure map cache is consistent since it may have shifted.
10730 if( m.has_zlevels() ) {
10731 for( int zlev = -OVERMAP_DEPTH; zlev <= OVERMAP_HEIGHT; ++zlev ) {
10732 m.invalidate_map_cache( zlev );
10733 }
10734 } else {
10736 }
10738
10739 // Spawn monsters if appropriate
10740 // This call will generate new monsters in addition to loading, so it's placed after NPC loading
10741 m.spawn_monsters( false ); // Static monsters
10742
10743 // Update what parts of the world map we can see
10745
10746 return shift;
10747}
void shift_destination(point shift)
void shift_monsters(const tripoint &shift)
Shift all active monsters, the shift vector is the number of shifted submaps.
Definition: game.cpp:11023
void shift(point s)
Shift the map along the vector s.
Definition: map.cpp:6878
void shift(point sm_shift)
Definition: scent_map.cpp:82
point sm_to_ms_copy(point p)
static constexpr int HALF_MAPSIZE_Y
static constexpr int HALF_MAPSIZE_X

References active_npc, map::build_map_cache(), clamp(), get_levz(), grid_tracker_ptr, HALF_MAPSIZE_X, HALF_MAPSIZE_Y, map::has_zlevels(), map::invalidate_map_cache(), load_npcs(), m, MAPSIZE, OVERMAP_DEPTH, OVERMAP_HEIGHT, point_zero, scent, SEEX, SEEY, Character::setpos(), map::shift(), scent_map::shift(), Character::shift_destination(), shift_monsters(), sm_to_ms_copy(), map::spawn_monsters(), u, update_overmap_seen(), point::x, and point::y.

◆ update_map() [2/2]

point game::update_map ( player p)

Definition at line 10648 of file game.cpp.

10649{
10650 point p2( p.posx(), p.posy() );
10651 return update_map( p2.x, p2.y );
10652}

References Character::posx(), Character::posy(), update_map(), point::x, and point::y.

Referenced by fling_creature(), load(), place_player(), start_game(), update_map(), and vertical_move().

◆ update_overmap_seen()

void game::update_overmap_seen ( )

Definition at line 10749 of file game.cpp.

10750{
10751 const tripoint_abs_omt ompos = u.global_omt_location();
10752 const int dist = u.overmap_sight_range( light_level( u.posz() ) );
10753 const int dist_squared = dist * dist;
10754 // We can always see where we're standing
10755 overmap_buffer.set_seen( ompos, true );
10756 for( const tripoint_abs_omt &p : points_in_radius( ompos, dist ) ) {
10757 const point_rel_omt delta = p.xy() - ompos.xy();
10758 const int h_squared = delta.x() * delta.x() + delta.y() * delta.y();
10759 if( trigdist && h_squared > dist_squared ) {
10760 continue;
10761 }
10762 if( delta == point_rel_omt() ) {
10763 // 1. This case is already handled outside of the loop
10764 // 2. Calculating multiplier would cause division by zero
10765 continue;
10766 }
10767 // If circular distances are enabled, scale overmap distances by the diagonality of the sight line.
10768 point abs_delta = delta.raw().abs();
10769 int max_delta = std::max( abs_delta.x, abs_delta.y );
10770 const float multiplier = trigdist ? std::sqrt( h_squared ) / max_delta : 1;
10771 const std::vector<tripoint_abs_omt> line = line_to( ompos, p );
10772 float sight_points = dist;
10773 for( auto it = line.begin();
10774 it != line.end() && sight_points >= 0; ++it ) {
10775 const oter_id &ter = overmap_buffer.ter( *it );
10776 sight_points -= static_cast<int>( ter->get_see_cost() ) * multiplier;
10777 }
10778 if( sight_points >= 0 ) {
10779 tripoint_abs_omt seen( p );
10780 do {
10781 overmap_buffer.set_seen( seen, true );
10782 --seen.z();
10783 } while( seen.z() >= 0 );
10784 }
10785 }
10786}
bool trigdist
Circular distances.
int overmap_sight_range(int light_level) const
Returns the distance the player can see on the overmap.
Definition: character.cpp:655
constexpr Point & raw()
Definition: coordinates.h:111
void set_seen(const tripoint_abs_omt &p, bool seen=true)
coords::coord_point< point, coords::origin::relative, coords::omt > point_rel_omt
Definition: coordinates.h:478
tripoint_range< Tripoint > points_in_radius(const Tripoint &center, const int radius, const int radiusz=0)
Definition: map_iterator.h:125
unsigned char get_see_cost() const
Definition: omdata.h:230

References oter_t::get_see_cost(), Character::global_omt_location(), light_level(), line(), line_to(), overmap_buffer, Character::overmap_sight_range(), points_in_radius(), Character::posz(), coords::coord_point< Point, Origin, Scale >::raw(), overmapbuffer::set_seen(), overmapbuffer::ter(), trigdist, u, coords::coord_point< Point, Origin, Scale >::x(), point::x, coords::coord_point< Point, Origin, Scale >::xy(), coords::coord_point< Point, Origin, Scale >::y(), point::y, and coords::coord_point< Point, Origin, Scale >::z().

Referenced by place_player_overmap(), and update_map().

◆ update_stair_monsters()

void game::update_stair_monsters ( )
private
Dodge reduces chance of being downed when pushed off the stairs

Definition at line 10801 of file game.cpp.

10802{
10803 // Search for the stairs closest to the player.
10804 std::vector<int> stairx;
10805 std::vector<int> stairy;
10806 std::vector<int> stairdist;
10807
10808 const bool from_below = monstairz < get_levz();
10809
10810 if( coming_to_stairs.empty() ) {
10811 return;
10812 }
10813
10814 if( m.has_zlevels() ) {
10815 debugmsg( "%d monsters coming to stairs on a map with z-levels",
10816 coming_to_stairs.size() );
10817 coming_to_stairs.clear();
10818 }
10819
10820 for( const tripoint &dest : m.points_on_zlevel( u.posz() ) ) {
10821 if( ( from_below && m.has_flag( "GOES_DOWN", dest ) ) ||
10822 ( !from_below && m.has_flag( "GOES_UP", dest ) ) ) {
10823 stairx.push_back( dest.x );
10824 stairy.push_back( dest.y );
10825 stairdist.push_back( rl_dist( dest, u.pos() ) );
10826 }
10827 }
10828 if( stairdist.empty() ) {
10829 return; // Found no stairs?
10830 }
10831
10832 // Find closest stairs.
10833 size_t si = 0;
10834 for( size_t i = 0; i < stairdist.size(); i++ ) {
10835 if( stairdist[i] < stairdist[si] ) {
10836 si = i;
10837 }
10838 }
10839
10840 // Find up to 4 stairs for distance stairdist[si] +1
10841 std::vector<int> nearest;
10842 nearest.push_back( si );
10843 for( size_t i = 0; i < stairdist.size() && nearest.size() < 4; i++ ) {
10844 if( ( i != si ) && ( stairdist[i] <= stairdist[si] + 1 ) ) {
10845 nearest.push_back( i );
10846 }
10847 }
10848 // Randomize the stair choice
10849 si = random_entry_ref( nearest );
10850
10851 // Attempt to spawn zombies.
10852 for( size_t i = 0; i < coming_to_stairs.size(); i++ ) {
10853 point mpos( stairx[si], stairy[si] );
10854 monster &critter = coming_to_stairs[i];
10855 const tripoint dest {
10856 mpos, g->get_levz()
10857 };
10858
10859 // We might be not be visible.
10860 if( ( critter.posx() < 0 - ( MAPSIZE_X ) / 6 ||
10861 critter.posy() < 0 - ( MAPSIZE_Y ) / 6 ||
10862 critter.posx() > ( MAPSIZE_X * 7 ) / 6 ||
10863 critter.posy() > ( MAPSIZE_Y * 7 ) / 6 ) ) {
10864 continue;
10865 }
10866
10867 critter.staircount -= 4;
10868 // Let the player know zombies are trying to come.
10869 if( u.sees( dest ) ) {
10870 std::string dump;
10871 if( critter.staircount > 4 ) {
10872 dump += string_format( _( "You see a %s on the stairs" ), critter.name() );
10873 } else {
10874 if( critter.staircount > 0 ) {
10875 dump += ( from_below ?
10876 //~ The <monster> is almost at the <bottom/top> of the <terrain type>!
10877 string_format( _( "The %1$s is almost at the top of the %2$s!" ),
10878 critter.name(),
10879 m.tername( dest ) ) :
10880 string_format( _( "The %1$s is almost at the bottom of the %2$s!" ),
10881 critter.name(),
10882 m.tername( dest ) ) );
10883 }
10884 }
10885
10886 add_msg( m_warning, dump );
10887 } else {
10889 _( "a sound nearby from the stairs!" ), true, "misc", "stairs_movement" );
10890 }
10891
10892 if( critter.staircount > 0 ) {
10893 continue;
10894 }
10895
10896 if( is_empty( dest ) ) {
10897 critter.spawn( dest );
10898 critter.staircount = 0;
10899 place_critter_at( make_shared_fast<monster>( critter ), dest );
10900 if( u.sees( dest ) ) {
10901 if( !from_below ) {
10902 add_msg( m_warning, _( "The %1$s comes down the %2$s!" ),
10903 critter.name(),
10904 m.tername( dest ) );
10905 } else {
10906 add_msg( m_warning, _( "The %1$s comes up the %2$s!" ),
10907 critter.name(),
10908 m.tername( dest ) );
10909 }
10910 }
10911 coming_to_stairs.erase( coming_to_stairs.begin() + i );
10912 continue;
10913 } else if( u.pos() == dest ) {
10914 // Monster attempts to push player of stairs
10916 int tries = 0;
10917
10918 // the critter is now right on top of you and will attack unless
10919 // it can find a square to push you into with one of his tries.
10920 const int creature_push_attempts = 9;
10921 const int player_throw_resist_chance = 3;
10922
10923 critter.spawn( dest );
10924 while( tries < creature_push_attempts ) {
10925 tries++;
10926 push.x = rng( -1, 1 );
10927 push.y = rng( -1, 1 );
10928 point ipos( mpos + push );
10929 tripoint pos( ipos, get_levz() );
10930 if( ( push.x != 0 || push.y != 0 ) && !critter_at( pos ) &&
10931 critter.can_move_to( pos ) ) {
10932 bool resiststhrow = ( u.is_throw_immune() ) ||
10934 if( resiststhrow && one_in( player_throw_resist_chance ) ) {
10935 u.moves -= 25; // small charge for avoiding the push altogether
10936 add_msg( _( "The %s fails to push you back!" ),
10937 critter.name() );
10938 return; //judo or leg brace prevent you from getting pushed at all
10939 }
10940 // Not accounting for tentacles latching on, so..
10941 // Something is about to happen, lets charge half a move
10942 u.moves -= 50;
10943 if( resiststhrow && ( u.is_throw_immune() ) ) {
10944 //we have a judoka who isn't getting pushed but counterattacking now.
10945 mattack::thrown_by_judo( &critter );
10946 return;
10947 }
10948 std::string msg;
10949 ///\EFFECT_DODGE reduces chance of being downed when pushed off the stairs
10950 if( !( resiststhrow ) && ( u.get_dodge() + rng( 0, 3 ) < 12 ) ) {
10951 // dodge 12 - never get downed
10952 // 11.. avoid 75%; 10.. avoid 50%; 9.. avoid 25%
10953 u.add_effect( effect_downed, 2_turns );
10954 msg = _( "The %s pushed you back hard!" );
10955 } else {
10956 msg = _( "The %s pushed you back!" );
10957 }
10958 add_msg( m_warning, msg.c_str(), critter.name() );
10959 u.setx( u.posx() + push.x );
10960 u.sety( u.posy() + push.y );
10961 return;
10962 }
10963 }
10965 _( "The %s tried to push you back but failed! It attacks you!" ),
10966 critter.name() );
10967 critter.melee_attack( u );
10968 u.moves -= 50;
10969 return;
10970 } else if( monster *const mon_ptr = critter_at<monster>( dest ) ) {
10971 // Monster attempts to displace a monster from the stairs
10972 monster &other = *mon_ptr;
10973 critter.spawn( dest );
10974
10975 // the critter is now right on top of another and will push it
10976 // if it can find a square to push it into inside of his tries.
10977 const int creature_push_attempts = 9;
10978 const int creature_throw_resist = 4;
10979
10980 int tries = 0;
10981 point push2;
10982 while( tries < creature_push_attempts ) {
10983 tries++;
10984 push2.x = rng( -1, 1 );
10985 push2.y = rng( -1, 1 );
10986 point ipos2( mpos + push2 );
10987 tripoint pos( ipos2, get_levz() );
10988 if( ( push2.x == 0 && push2.y == 0 ) || ( ( ipos2.x == u.posx() ) && ( ipos2.y == u.posy() ) ) ) {
10989 continue;
10990 }
10991 if( !critter_at( pos ) && other.can_move_to( pos ) ) {
10992 other.setpos( tripoint( ipos2, get_levz() ) );
10993 other.moves -= 50;
10994 std::string msg;
10995 if( one_in( creature_throw_resist ) ) {
10996 other.add_effect( effect_downed, 2_turns );
10997 msg = _( "The %1$s pushed the %2$s hard." );
10998 } else {
10999 msg = _( "The %1$s pushed the %2$s." );
11000 }
11001 add_msg( m_neutral, msg, critter.name(), other.name() );
11002 return;
11003 }
11004 }
11005 return;
11006 }
11007 }
11008}
void setx(int x)
Definition: character.h:806
void sety(int y)
Definition: character.h:809
bool is_throw_immune() const
Returns true if the player is immune to throws.
float get_dodge() const override
Definition: melee.cpp:838
int monstairz
Definition: game.h:983
tripoint_range< tripoint > points_on_zlevel() const
Yields a range of all points that are contained in the map and have the z-level of this map (abs_sub)...
Definition: map.cpp:8754
bool can_move_to(const tripoint &p) const
Checks whether we can move to/through p.
Definition: monmove.cpp:258
int posy() const override
Definition: monster.h:498
void melee_attack(Creature &target)
Definition: monster.cpp:1414
int staircount
Definition: monster.h:509
void spawn(const tripoint &p)
Definition: monster.cpp:478
int posx() const override
Definition: monster.h:495
bool thrown_by_judo(monster *z)
Definition: monattack.cpp:4675
std::enable_if<!is_std_array< C >::value, constV & >::type random_entry_ref(const C &container)
Same as above, but with a statically allocated default value (using the default constructor).
Definition: rng.h:149

References _, Creature::add_effect(), add_msg(), monster::can_move_to(), coming_to_stairs, critter_at(), debugmsg, effect_downed, g, Character::get_dodge(), get_levz(), map::has_flag(), Character::has_trait(), map::has_zlevels(), is_empty(), Character::is_throw_immune(), m, m_neutral, m_warning, MAPSIZE_X, MAPSIZE_Y, monster::melee_attack(), monstairz, sounds::movement, Creature::moves, monster::name(), one_in(), other, place_critter_at(), point_north_west, map::points_on_zlevel(), Character::pos(), Character::posx(), monster::posx(), Character::posy(), monster::posy(), Character::posz(), monexamine::push(), random_entry_ref(), rl_dist(), rng(), Character::sees(), Character::setx(), Character::sety(), sounds::sound(), monster::spawn(), monster::staircount, string_format(), map::tername(), mattack::thrown_by_judo(), trait_LEG_TENT_BRACE, u, point::x, and point::y.

Referenced by do_turn(), and vertical_move().

◆ update_zombie_pos()

bool game::update_zombie_pos ( const monster critter,
const tripoint pos 
)

Redirects to the creature_tracker update_pos() function.

Definition at line 4720 of file game.cpp.

4721{
4722 return critter_tracker->update_pos( critter, pos );
4723}

References critter_tracker.

◆ use_computer()

void game::use_computer ( const tripoint p)

Checks to see if a player can use a computer (not illiterate, etc.) and uses if able.

Definition at line 4503 of file game.cpp.

4504{
4505 if( u.has_trait( trait_id( "ILLITERATE" ) ) ) {
4506 add_msg( m_info, _( "You can not read a computer screen!" ) );
4507 return;
4508 }
4509 if( u.is_blind() ) {
4510 // we don't have screen readers in game
4511 add_msg( m_info, _( "You can not see a computer screen!" ) );
4512 return;
4513 }
4514 if( u.has_trait( trait_id( "HYPEROPIC" ) ) && !u.worn_with_flag( "FIX_FARSIGHT" ) &&
4515 !u.has_effect( effect_contacts ) && !u.has_bionic( bionic_id( "bio_eye_optic" ) ) ) {
4516 add_msg( m_info, _( "You'll need to put on reading glasses before you can see the screen." ) );
4517 return;
4518 }
4519
4520 computer *used = m.computer_at( p );
4521
4522 if( used == nullptr ) {
4523 if( m.has_flag( "CONSOLE", p ) ) { //Console without map data
4524 add_msg( m_bad, _( "The console doesn't display anything coherent." ) );
4525 } else {
4526 debugmsg( "Tried to use computer at %s - none there", p.to_string() );
4527 }
4528 return;
4529 }
4530
4531 computer_session( *used ).use();
4532}
void use()
Handles player use of a computer.
computer * computer_at(const tripoint &p)
Definition: map.cpp:5653
static const efftype_id effect_contacts("contacts")

References _, add_msg(), map::computer_at(), debugmsg, effect_contacts, Character::has_bionic(), Creature::has_effect(), map::has_flag(), Character::has_trait(), Character::is_blind(), m, m_bad, m_info, tripoint::to_string(), u, computer_session::use(), and Character::worn_with_flag().

Referenced by examine().

◆ validate_camps()

void game::validate_camps ( )

validate camps to ensure they are on the overmap list

Definition at line 1962 of file game.cpp.

1963{
1964 basecamp camp = m.hoist_submap_camp( u.pos() );
1965 if( camp.is_valid() ) {
1966 overmap_buffer.add_camp( camp );
1968 } else if( camp.camp_omt_pos() != tripoint_abs_omt() ) {
1969 std::string camp_name = _( "Faction Camp" );
1970 camp.set_name( camp_name );
1971 overmap_buffer.add_camp( camp );
1973 }
1974}
bool is_valid() const
Definition: basecamp.h:125
void set_name(const std::string &new_name)
Definition: basecamp.cpp:575
tripoint_abs_omt camp_omt_pos() const
Definition: basecamp.h:134
basecamp hoist_submap_camp(const tripoint &p)
Definition: map.cpp:5684
void remove_submap_camp(const tripoint &)
Definition: map.cpp:5679
void add_camp(const basecamp &camp)
Add Basecamp to overmapbuffer.

References _, overmapbuffer::add_camp(), basecamp::camp_omt_pos(), map::hoist_submap_camp(), basecamp::is_valid(), m, overmap_buffer, Character::pos(), map::remove_submap_camp(), basecamp::set_name(), and u.

Referenced by load().

◆ validate_linked_vehicles()

void game::validate_linked_vehicles ( )

validate towed vehicles so they get linked up again after a load

Definition at line 1904 of file game.cpp.

1905{
1906 for( auto &veh : m.get_vehicles() ) {
1907 vehicle *v = veh.v;
1910 if( other_v ) {
1911 // the other vehicle is towing us.
1912 v->tow_data.set_towing( other_v, v );
1914 }
1915 }
1916 }
1917}
tripoint other_towing_point
Definition: vehicle.h:168
bool set_towing(vehicle *tower_veh, vehicle *towed_veh)
Definition: vehicle.cpp:6119
towing_data tow_data
Definition: vehicle.h:1969

References map::get_vehicles(), m, towing_data::other_towing_point, towing_data::set_towing(), vehicle::tow_data, tripoint_zero, map::veh_at(), and veh_pointer_or_null().

Referenced by load().

◆ validate_mounted_npcs()

void game::validate_mounted_npcs ( )

Definition at line 1919 of file game.cpp.

1920{
1921 for( monster &m : all_monsters() ) {
1922 if( m.has_effect( effect_ridden ) && m.mounted_player_id.is_valid() ) {
1923 player *mounted_pl = g->critter_by_id<player>( m.mounted_player_id );
1924 if( !mounted_pl ) {
1925 // Target no longer valid.
1926 m.mounted_player_id = character_id();
1927 m.remove_effect( effect_ridden );
1928 continue;
1929 }
1930 mounted_pl->mounted_creature = shared_from( m );
1931 mounted_pl->setpos( m.pos() );
1932 mounted_pl->add_effect( effect_riding, 1_turns, num_bp );
1933 m.mounted_player = mounted_pl;
1934 }
1935 }
1936}

References Creature::add_effect(), all_monsters(), character_id, effect_ridden, effect_riding, g, m, Character::mounted_creature, num_bp, Character::setpos(), and shared_from().

Referenced by load(), and vertical_shift().

◆ validate_npc_followers()

void game::validate_npc_followers ( )

validate list of followers to account for overmap buffers

Definition at line 1938 of file game.cpp.

1939{
1940 // Make sure visible followers are in the list.
1941 const std::vector<npc *> visible_followers = get_npcs_if( [&]( const npc & guy ) {
1942 return guy.is_player_ally();
1943 } );
1944 for( npc *guy : visible_followers ) {
1945 update_faction_api( guy );
1946 add_npc_follower( guy->getID() );
1947 }
1948 // Make sure overmapbuffered NPC followers are in the list.
1949 for( const auto &temp_guy : overmap_buffer.get_npcs_near_player( 300 ) ) {
1950 npc *guy = temp_guy.get();
1951 if( guy->is_player_ally() ) {
1952 update_faction_api( guy );
1953 add_npc_follower( guy->getID() );
1954 }
1955 }
1956 // Make sure that serialized player followers sync up with game list
1957 for( const auto &temp_id : u.follower_ids ) {
1958 add_npc_follower( temp_id );
1959 }
1960}
void add_npc_follower(const character_id &id)
Add follower id to set of followers.
Definition: game.cpp:1884
static void update_faction_api(npc *guy)
Definition: game.cpp:1896

References add_npc_follower(), player::follower_ids, get_npcs_if(), overmapbuffer::get_npcs_near_player(), Character::getID(), npc::is_player_ally(), overmap_buffer, u, and update_faction_api().

Referenced by load().

◆ vertical_move()

void game::vertical_move ( int  z,
bool  force,
bool  peeking = false 
)

Moves the player vertically.

If force == true then they are falling. If peeking == true, forbids some exotic movement options

Strength increases breath-holding capacity while diving Dexterity increases chance of moving past monsters on stairs Dodge increases chance of moving past monsters on stairs Strength increases chance of moving past monsters on stairs Melee increases chance of moving past monsters on stairs

Definition at line 9975 of file game.cpp.

9976{
9977 if( u.is_mounted() ) {
9978 auto mons = u.mounted_creature.get();
9979 if( mons->has_flag( MF_RIDEABLE_MECH ) ) {
9980 if( !mons->check_mech_powered() ) {
9981 add_msg( m_bad, _( "Your %s refuses to move as its batteries have been drained." ),
9982 mons->get_name() );
9983 return;
9984 }
9985 }
9986 }
9987
9988 // > and < are used for diving underwater.
9989 if( m.has_flag( "SWIMMABLE", u.pos() ) && m.has_flag( TFLAG_DEEP_WATER, u.pos() ) ) {
9990 if( movez == -1 ) {
9991 if( u.is_underwater() ) {
9992 add_msg( m_info, _( "You are already underwater!" ) );
9993 return;
9994 }
9995 if( u.worn_with_flag( "FLOTATION" ) ) {
9996 add_msg( m_info, _( "You can't dive while wearing a flotation device." ) );
9997 return;
9998 }
9999 u.set_underwater( true );
10000 ///\EFFECT_STR increases breath-holding capacity while diving
10001 u.oxygen = 30 + 2 * u.str_cur;
10002 add_msg( _( "You dive underwater!" ) );
10003 } else {
10004 if( u.swim_speed() < 500 || u.shoe_type_count( itype_swim_fins ) ) {
10005 u.set_underwater( false );
10006 add_msg( _( "You surface." ) );
10007 } else {
10008 add_msg( m_info, _( "You try to surface but can't!" ) );
10009 }
10010 }
10011 u.moves -= 100;
10012 return;
10013 }
10014
10015 // Force means we're going down, even if there's no staircase, etc.
10016 bool climbing = false;
10017 int move_cost = 100;
10018 tripoint stairs( u.posx(), u.posy(), u.posz() + movez );
10019 if( m.has_zlevels() && !force && movez == 1 && !m.has_flag( "GOES_UP", u.pos() ) ) {
10020 // Climbing
10021 if( m.has_floor_or_support( stairs ) ) {
10022 add_msg( m_info, _( "You can't climb here - there's a ceiling above your head." ) );
10023 return;
10024 }
10025
10026 std::vector<tripoint> pts;
10027 for( const auto &pt : m.points_in_radius( stairs, 1 ) ) {
10028 if( m.passable( pt ) &&
10029 m.has_floor_or_support( pt ) ) {
10030 pts.push_back( pt );
10031 }
10032 }
10033
10034 const int cost = map_funcs::climbing_cost( m, u.pos(), stairs );
10035
10036 if( cost == 0 ) {
10037 if( u.has_trait( trait_WEB_ROPE ) ) {
10038 if( pts.empty() ) {
10039 add_msg( m_info, _( "There is nothing above you that you can attach a web to." ) );
10040 } else if( can_use_mutation_warn( trait_WEB_ROPE, u ) ) {
10041 if( m.move_cost( u.pos() ) != 2 && m.move_cost( u.pos() ) != 3 ) {
10042 add_msg( m_info, _( "You can't spin a web rope there." ) );
10043 } else if( m.has_furn( u.pos() ) ) {
10044 add_msg( m_info, _( "There is already furniture at that location." ) );
10045 } else {
10046 if( query_yn( "Spin a rope and climb?" ) ) {
10047 add_msg( m_good, _( "You spin a rope of web." ) );
10048 m.furn_set( u.pos(), furn_str_id( "f_rope_up_web" ) );
10049 u.mod_moves( to_turns<int>( 2_seconds ) );
10051 vertical_move( movez, force, peeking );
10052 }
10053 }
10054 }
10055
10056 } else {
10057 add_msg( m_info, _( "You can't climb here - you need walls and/or furniture to brace against." ) );
10058
10059 }
10060 return;
10061
10062 }
10063
10064 if( cost <= 0 || pts.empty() ) {
10065 add_msg( m_info,
10066 _( "You can't climb here - there is no terrain above you that would support your weight." ) );
10067 return;
10068 } else {
10069 // TODO: Make it an extended action
10070 climbing = true;
10071 move_cost = cost;
10072
10073 const std::optional<tripoint> pnt = point_selection_menu( pts );
10074 if( !pnt ) {
10075 return;
10076 }
10077 stairs = *pnt;
10078 }
10079 }
10080
10081 if( !force && movez == -1 && !m.has_flag( "GOES_DOWN", u.pos() ) ) {
10082 add_msg( m_info, _( "You can't go down here!" ) );
10083 return;
10084 } else if( !climbing && !force && movez == 1 && !m.has_flag( "GOES_UP", u.pos() ) ) {
10085 add_msg( m_info, _( "You can't go up here!" ) );
10086 return;
10087 }
10088
10089 if( force ) {
10090 // Let go of a grabbed cart.
10091 u.grab( OBJECT_NONE );
10092 } else if( u.grab_point != tripoint_zero ) {
10093 add_msg( m_info, _( "You can't drag things up and down stairs." ) );
10094 return;
10095 }
10096
10097 // Because get_levz takes z-value from the map, it will change when vertical_shift (m.has_zlevels() == true)
10098 // is called or when the map is loaded on new z-level (== false).
10099 // This caches the z-level we start the movement on (current) and the level we're want to end.
10100 const int z_before = get_levz();
10101 const int z_after = get_levz() + movez;
10102 if( z_after < -OVERMAP_DEPTH || z_after > OVERMAP_HEIGHT ) {
10103 debugmsg( "Tried to move outside allowed range of z-levels" );
10104 return;
10105 }
10106
10107 if( !u.move_effects( false ) ) {
10108 return;
10109 }
10110
10111 // Check if there are monsters are using the stairs.
10112 bool slippedpast = false;
10113 if( !m.has_zlevels() && !coming_to_stairs.empty() && !force ) {
10114 // TODO: Allow travel if zombie couldn't reach stairs, but spawn him when we go up.
10115 add_msg( m_warning, _( "You try to use the stairs. Suddenly you are blocked by a %s!" ),
10116 coming_to_stairs[0].name() );
10117 // Roll.
10118 ///\EFFECT_DEX increases chance of moving past monsters on stairs
10119
10120 ///\EFFECT_DODGE increases chance of moving past monsters on stairs
10121 int dexroll = dice( 6, u.dex_cur + u.get_skill_level( skill_dodge ) * 2 );
10122 ///\EFFECT_STR increases chance of moving past monsters on stairs
10123
10124 ///\EFFECT_MELEE increases chance of moving past monsters on stairs
10125 int strroll = dice( 3, u.str_cur + u.get_skill_level( skill_melee ) * 1.5 );
10126 if( coming_to_stairs.size() > 4 ) {
10127 add_msg( _( "The are a lot of them on the %s!" ), m.tername( u.pos() ) );
10128 dexroll /= 4;
10129 strroll /= 2;
10130 } else if( coming_to_stairs.size() > 1 ) {
10131 add_msg( m_warning, _( "There's something else behind it!" ) );
10132 dexroll /= 2;
10133 }
10134
10135 if( dexroll < 14 || strroll < 12 ) {
10137 u.moves -= 100;
10138 return;
10139 }
10140
10141 add_msg( _( "You manage to slip past!" ) );
10142 slippedpast = true;
10143 u.moves -= 100;
10144 }
10145
10146 // Shift the map up or down
10147
10148 std::unique_ptr<map> tmp_map_ptr;
10149 if( !m.has_zlevels() ) {
10150 tmp_map_ptr = std::make_unique<map>();
10151 }
10152
10153 map &maybetmp = m.has_zlevels() ? m : *( tmp_map_ptr.get() );
10154 if( m.has_zlevels() ) {
10155 // We no longer need to shift the map here! What joy
10156 } else {
10157 maybetmp.load( tripoint( get_levx(), get_levy(), z_after ), false );
10158 }
10159
10160 // Find the corresponding staircase
10161 bool rope_ladder = false;
10162 // TODO: Remove the stairfinding, make the mapgen gen aligned maps
10163 if( !force && !climbing ) {
10164 const std::optional<tripoint> pnt = find_or_make_stairs( maybetmp, z_after, rope_ladder, peeking );
10165 if( !pnt ) {
10166 return;
10167 }
10168 stairs = *pnt;
10169 }
10170
10171 if( !force ) {
10172 monstairz = z_before;
10173 }
10174 // Save all monsters that can reach the stairs, remove them from the tracker,
10175 // then despawn the remaining monsters. Because it's a vertical shift, all
10176 // monsters are out of the bounds of the map and will despawn.
10177 shared_ptr_fast<monster> stored_mount;
10178 if( u.is_mounted() && !m.has_zlevels() ) {
10179 // Store a *copy* of the mount, so we can remove the original monster instance
10180 // from the tracker before the map shifts.
10181 // Map shifting would otherwise just despawn the mount and would later respawn it.
10182 stored_mount = make_shared_fast<monster>( *u.mounted_creature );
10184 }
10185 if( !m.has_zlevels() ) {
10186 const tripoint to = u.pos();
10187 for( monster &critter : all_monsters() ) {
10188 // if its a ladder instead of stairs - most zombies can't climb that.
10189 // unless that have a special flag to allow them to do so.
10190 if( ( m.has_flag( "DIFFICULT_Z", u.pos() ) && !critter.climbs() ) ||
10191 critter.has_effect( effect_ridden ) ||
10192 critter.has_effect( effect_tied ) ) {
10193 continue;
10194 }
10195 int turns = critter.turns_to_reach( to.xy() );
10196 if( turns < 10 && coming_to_stairs.size() < 8 && critter.will_reach( to.xy() )
10197 && !slippedpast ) {
10198 critter.staircount = 10 + turns;
10199 critter.on_unload();
10200 coming_to_stairs.push_back( critter );
10201 remove_zombie( critter );
10202 }
10203 }
10204 auto mons = critter_tracker->find( g->u.pos() );
10205 if( mons != nullptr ) {
10206 critter_tracker->remove( *mons );
10207 }
10208 shift_monsters( tripoint( 0, 0, movez ) );
10209 }
10210
10211 std::vector<shared_ptr_fast<npc>> npcs_to_bring;
10212 std::vector<monster *> monsters_following;
10213 if( !m.has_zlevels() && std::abs( movez ) == 1 ) {
10214 std::copy_if( active_npc.begin(), active_npc.end(), back_inserter( npcs_to_bring ),
10215 [this]( const shared_ptr_fast<npc> &np ) {
10216 return np->is_walking_with() && !np->is_mounted() && !np->in_sleep_state() &&
10217 rl_dist( np->pos(), u.pos() ) < 2;
10218 } );
10219 }
10220
10221 if( m.has_zlevels() && std::abs( movez ) == 1 ) {
10222 bool ladder = m.has_flag( "DIFFICULT_Z", u.pos() );
10223 for( monster &critter : all_monsters() ) {
10224 if( ladder && !critter.climbs() ) {
10225 continue;
10226 }
10227 if( critter.attack_target() == &g->u || ( !critter.has_effect( effect_ridden ) &&
10228 critter.has_effect( effect_pet ) && critter.friendly == -1 &&
10229 !critter.has_effect( effect_tied ) ) ) {
10230 monsters_following.push_back( &critter );
10231 }
10232 }
10233 }
10234
10235 if( u.is_mounted() ) {
10236 monster *crit = u.mounted_creature.get();
10237 if( crit->has_flag( MF_RIDEABLE_MECH ) ) {
10238 crit->use_mech_power( -1 );
10239 if( u.movement_mode_is( CMM_WALK ) ) {
10240 crit->use_mech_power( -2 );
10241 } else if( u.movement_mode_is( CMM_CROUCH ) ) {
10242 crit->use_mech_power( -1 );
10243 } else if( u.movement_mode_is( CMM_RUN ) ) {
10244 crit->use_mech_power( -3 );
10245 }
10246 }
10247 } else {
10248 u.moves -= move_cost;
10249 }
10250 for( const auto &np : npcs_to_bring ) {
10251 if( np->in_vehicle ) {
10252 m.unboard_vehicle( np->pos() );
10253 }
10254 }
10255 const tripoint old_pos = g->u.pos();
10256 point submap_shift;
10257 vertical_shift( z_after );
10258 if( !force ) {
10259 submap_shift = update_map( stairs.x, stairs.y );
10260 }
10261
10262 // if an NPC or monster is on the stiars when player ascends/descends
10263 // they may end up merged on th esame tile, do some displacement to resolve that.
10264 // if, in the weird case of it not being possible to displace;
10265 // ( how did the player even manage to approach the stairs, if so? )
10266 // then nothing terrible happens, its just weird.
10267 if( critter_at<npc>( u.pos(), true ) || critter_at<monster>( u.pos(), true ) ) {
10268 std::string crit_name;
10269 bool player_displace = false;
10270 std::optional<tripoint> displace = find_empty_spot_nearby( u.pos() );
10271 if( displace.has_value() ) {
10272 npc *guy = g->critter_at<npc>( u.pos(), true );
10273 if( guy ) {
10274 crit_name = guy->get_name();
10275 tripoint old_pos = guy->pos();
10276 if( !guy->is_enemy() ) {
10277 guy->move_away_from( u.pos(), true );
10278 if( old_pos != guy->pos() ) {
10279 add_msg( _( "%s moves out of the way for you." ), guy->get_name() );
10280 }
10281 } else {
10282 player_displace = true;
10283 }
10284 }
10285 monster *mon = g->critter_at<monster>( u.pos(), true );
10286 // if the monster is ridden by the player or an NPC:
10287 // Dont displace them. If they are mounted by a friendly NPC,
10288 // then the NPC will already have been displaced just above.
10289 // if they are ridden by the player, we want them to coexist on same tile
10290 if( mon && !mon->mounted_player ) {
10291 crit_name = mon->get_name();
10292 if( mon->friendly == -1 ) {
10293 mon->setpos( *displace );
10294 add_msg( _( "Your %s moves out of the way for you." ), mon->get_name() );
10295 } else {
10296 player_displace = true;
10297 }
10298 }
10299 if( player_displace ) {
10300 u.setpos( *displace );
10301 u.moves -= 20;
10302 add_msg( _( "You push past %s blocking the way." ), crit_name );
10303 }
10304 } else {
10305 debugmsg( "Failed to find a spot to displace into." );
10306 }
10307 }
10308
10309 // Now that we know the player's destination position, we can move their mount as well
10310 if( u.is_mounted() ) {
10311 if( stored_mount ) {
10312 assert( !m.has_zlevels() );
10313 stored_mount->spawn( g->u.pos() );
10314 if( critter_tracker->add( stored_mount ) ) {
10315 u.mounted_creature = stored_mount;
10316 }
10317 } else {
10318 u.mounted_creature->setpos( g->u.pos() );
10319 }
10320 }
10321
10322 if( !npcs_to_bring.empty() ) {
10323 // Would look nicer randomly scrambled
10324 std::vector<tripoint> candidates = closest_points_first( u.pos(), 1 );
10325 candidates.erase( std::remove_if( candidates.begin(), candidates.end(),
10326 [this]( const tripoint & c ) {
10327 return !is_empty( c );
10328 } ), candidates.end() );
10329
10330 for( const auto &np : npcs_to_bring ) {
10331 const auto found = std::find_if( candidates.begin(), candidates.end(),
10332 [this, np]( const tripoint & c ) {
10333 return !np->is_dangerous_fields( m.field_at( c ) ) && m.tr_at( c ).is_benign();
10334 } );
10335 if( found != candidates.end() ) {
10336 // TODO: De-uglify
10337 np->setpos( *found );
10338 np->place_on_map();
10339 np->setpos( *found );
10340 candidates.erase( found );
10341 }
10342
10343 if( candidates.empty() ) {
10344 break;
10345 }
10346 }
10347
10348 reload_npcs();
10349 }
10350
10351 // This ugly check is here because of stair teleport bullshit
10352 // TODO: Remove stair teleport bullshit
10353 if( rl_dist( g->u.pos(), old_pos ) <= 1 ) {
10354 for( monster *m : monsters_following ) {
10355 m->set_dest( g->u.pos() );
10356 }
10357 }
10358
10359 if( rope_ladder ) {
10360 m.ter_set( u.pos(), t_rope_up );
10361 }
10362
10363 if( m.ter( stairs ) == t_manhole_cover ) {
10364 m.spawn_item( stairs + point( rng( -1, 1 ), rng( -1, 1 ) ), itype_manhole_cover );
10365 m.ter_set( stairs, t_manhole );
10366 }
10367
10368 // Wouldn't work and may do strange things
10369 if( u.is_hauling() && !m.has_zlevels() ) {
10370 add_msg( _( "You cannot haul items here." ) );
10371 u.stop_hauling();
10372 }
10373
10374 if( u.is_hauling() ) {
10375 const tripoint adjusted_pos = old_pos - sm_to_ms_copy( submap_shift );
10376 start_hauling( adjusted_pos );
10377 }
10378
10379 m.invalidate_map_cache( g->get_levz() );
10380 // Upon force movement, traps can not be avoided.
10381 m.creature_on_trap( u, !force );
10382
10384}
static int move_cost(const item &it, const tripoint &src, const tripoint &dest)
@ CMM_WALK
Definition: character.h:109
@ CMM_CROUCH
Definition: character.h:111
bool move_effects(bool attacking) override
Processes effects which may prevent the Character from moving (bear traps, crushed,...
Definition: character.cpp:1470
int swim_speed() const
Returns the player's speed for swimming across water tiles.
Definition: character.cpp:814
int oxygen
Definition: character.h:1589
void mutation_spend_resources(const trait_id &mut)
Removes the appropriate costs (NOTE: will reapply mods & recalc sightlines in case of newly activated...
Definition: mutation.cpp:1698
int shoe_type_count(const itype_id &it) const
Returns 1 if the player is wearing an item of that count on one foot, 2 if on both,...
Definition: character.cpp:8929
std::string get_name() const override
Definition: character.cpp:5986
void set_underwater(bool x) override
void start_hauling(const tripoint &pos)
Definition: game.cpp:10386
std::optional< tripoint > find_or_make_stairs(map &mp, int z_after, bool &rope_ladder, bool peeking)
Returns the other end of the stairs (if any).
Definition: game.cpp:10421
bool use_mech_power(int amt)
Definition: monster.cpp:2435
Character * mounted_player
Definition: monster.h:458
static const efftype_id effect_tied("tied")
static const itype_id itype_manhole_cover("manhole_cover")
static std::optional< tripoint > point_selection_menu(const std::vector< tripoint > &pts)
Definition: game.cpp:9925
static const skill_id skill_melee("melee")
static const itype_id itype_swim_fins("swim_fins")
static const trait_id trait_WEB_ROPE("WEB_ROPE")
ter_id t_rope_up
Definition: mapdata.cpp:721
ter_id t_manhole
Definition: mapdata.cpp:720
bool can_use_mutation_warn(const trait_id &mut, const Character &character)
Calls can_use_mutation and if it fails, print a standard message.
Definition: mutation.cpp:1687
void avatar_moves(const avatar &u, const map &m, const tripoint &p)
Definition: game.cpp:12060
int ladder(player *, item *, bool, const tripoint &)
Definition: iuse.cpp:9364
int climbing_cost(const map &m, const tripoint &from, const tripoint &to)
Checks both the neighborhoods of from and to for climbable surfaces, returns move cost of climbing fr...
point displace(type dir, int dist=1)
Returns point(0, 0) displaced in specified direction by a specified distance.
Definition: overmap.cpp:4178

References _, active_npc, add_msg(), all_monsters(), cata_event_dispatch::avatar_moves(), c, can_use_mutation_warn(), map_funcs::climbing_cost(), closest_points_first(), CMM_CROUCH, CMM_RUN, CMM_WALK, coming_to_stairs, map::creature_on_trap(), critter_tracker, debugmsg, Character::dex_cur, dice(), om_direction::displace(), effect_pet, effect_ridden, effect_tied, find_empty_spot_nearby(), find_or_make_stairs(), monster::friendly, map::furn_set(), g, get_levx(), get_levy(), get_levz(), Character::get_name(), monster::get_name(), Character::get_skill_level(), avatar::grab(), player::grab_point, map::has_flag(), monster::has_flag(), map::has_floor_or_support(), map::has_furn(), Character::has_trait(), map::has_zlevels(), map::invalidate_map_cache(), npc::is_enemy(), Character::is_hauling(), Character::is_mounted(), Creature::is_underwater(), itype_manhole_cover, itype_swim_fins, iuse::ladder(), map::load(), m, m_bad, m_good, m_info, m_warning, MF_RIDEABLE_MECH, Creature::mod_moves(), monstairz, Character::mounted_creature, monster::mounted_player, npc::move_away_from(), move_cost(), map::move_cost(), Character::move_effects(), Character::movement_mode_is(), Creature::moves, Character::mutation_spend_resources(), om_direction::name(), OBJECT_NONE, OVERMAP_HEIGHT, Character::oxygen, map::passable(), point_selection_menu(), map::points_in_radius(), Character::pos(), Character::posx(), Character::posy(), Character::posz(), query_yn(), reload_npcs(), remove_zombie(), rl_dist(), rng(), Character::set_underwater(), Character::setpos(), monster::setpos(), shift_monsters(), Character::shoe_type_count(), skill_dodge, skill_melee, sm_to_ms_copy(), map::spawn_item(), start_hauling(), Character::stop_hauling(), Character::str_cur, Character::swim_speed(), t_manhole, t_manhole_cover, t_rope_up, map::ter(), map::ter_set(), map::tername(), TFLAG_DEEP_WATER, trait_WEB_ROPE, tripoint_zero, u, map::unboard_vehicle(), update_map(), update_stair_monsters(), monster::use_mech_power(), vertical_move(), vertical_shift(), Character::worn_with_flag(), tripoint::x, tripoint::xy(), and tripoint::y.

Referenced by handle_action(), peek(), and vertical_move().

◆ vertical_notes()

void game::vertical_notes ( int  z_before,
int  z_after 
)

Add goes up/down auto_notes (if turned on)

Definition at line 10608 of file game.cpp.

10609{
10610 if( z_before == z_after || !get_option<bool>( "AUTO_NOTES" ) ||
10611 !get_option<bool>( "AUTO_NOTES_STAIRS" ) ) {
10612 return;
10613 }
10614
10615 if( !m.inbounds_z( z_before ) || !m.inbounds_z( z_after ) ) {
10616 debugmsg( "game::vertical_notes invalid arguments: z_before == %d, z_after == %d",
10617 z_before, z_after );
10618 return;
10619 }
10620 // Figure out where we know there are up/down connectors
10621 // Fill in all the tiles we know about (e.g. subway stations)
10622 static const int REVEAL_RADIUS = 40;
10623 for( const tripoint_abs_omt &p : points_in_radius( u.global_omt_location(), REVEAL_RADIUS ) ) {
10624 const tripoint_abs_omt cursp_before( p.xy(), z_before );
10625 const tripoint_abs_omt cursp_after( p.xy(), z_after );
10626
10627 if( !overmap_buffer.seen( cursp_before ) ) {
10628 continue;
10629 }
10630 if( overmap_buffer.has_note( cursp_after ) ) {
10631 // Already has a note -> never add an AUTO-note
10632 continue;
10633 }
10634 const oter_id &ter = overmap_buffer.ter( cursp_before );
10635 const oter_id &ter2 = overmap_buffer.ter( cursp_after );
10636 if( z_after > z_before && ter->has_flag( known_up ) &&
10637 !ter2->has_flag( known_down ) ) {
10638 overmap_buffer.set_seen( cursp_after, true );
10639 overmap_buffer.add_note( cursp_after, string_format( ">:W;%s", _( "AUTO: goes down" ) ) );
10640 } else if( z_after < z_before && ter->has_flag( known_down ) &&
10641 !ter2->has_flag( known_up ) ) {
10642 overmap_buffer.set_seen( cursp_after, true );
10643 overmap_buffer.add_note( cursp_after, string_format( "<:W;%s", _( "AUTO: goes up" ) ) );
10644 }
10645 }
10646}
bool inbounds_z(const int z) const
Definition: map.h:1623
void add_note(const tripoint_abs_omt &, const std::string &message)
@ known_up
Definition: omdata.h:87
@ known_down
Definition: omdata.h:86
bool has_flag(oter_flags flag) const
Definition: omdata.h:258

References _, overmapbuffer::add_note(), debugmsg, Character::global_omt_location(), oter_t::has_flag(), overmapbuffer::has_note(), map::inbounds_z(), known_down, known_up, m, overmap_buffer, points_in_radius(), overmapbuffer::seen(), overmapbuffer::set_seen(), string_format(), overmapbuffer::ter(), and u.

Referenced by vertical_shift().

◆ vertical_shift()

void game::vertical_shift ( int  z_after)

Actual z-level movement part of vertical_move.

Doesn't include stair finding, traps etc.

Definition at line 10571 of file game.cpp.

10572{
10573 if( z_after < -OVERMAP_DEPTH || z_after > OVERMAP_HEIGHT ) {
10574 debugmsg( "Tried to get z-level %d outside allowed range of %d-%d",
10575 z_after, -OVERMAP_DEPTH, OVERMAP_HEIGHT );
10576 return;
10577 }
10578
10579 // TODO: Implement dragging stuff up/down
10580 u.grab( OBJECT_NONE );
10581
10582 scent.reset();
10583
10584 u.setz( z_after );
10585 const int z_before = get_levz();
10586 if( !m.has_zlevels() ) {
10588 m.access_cache( z_before ).vehicle_list.clear();
10589 m.access_cache( z_before ).zone_vehicles.clear();
10590 m.access_cache( z_before ).map_memory_seen_cache.reset();
10591 m.set_transparency_cache_dirty( z_before );
10592 m.set_outside_cache_dirty( z_before );
10593 m.load( tripoint( get_levx(), get_levy(), z_after ), true );
10594 shift_monsters( tripoint( 0, 0, z_after - z_before ) );
10595 reload_npcs();
10596 } else {
10597 // Shift the map itself
10598 m.vertical_shift( z_after );
10599 }
10600
10601 m.spawn_monsters( true );
10602 // this may be required after a vertical shift if z-levels are not enabled
10603 // the critter is unloaded/loaded, and it needs to reconstruct its rider data after being reloaded.
10605 vertical_notes( z_before, z_after );
10606}
void setz(int z)
Definition: character.h:812
void vertical_notes(int z_before, int z_after)
Add goes up/down auto_notes (if turned on)
Definition: game.cpp:10608
void set_transparency_cache_dirty(const int zlev)
Sets a dirty flag on the a given cache.
Definition: map.cpp:200
void set_outside_cache_dirty(const int zlev)
Definition: map.cpp:221
void vertical_shift(int newz)
Moves the map vertically to (not by!) newz.
Definition: map.cpp:7021
std::set< vehicle * > zone_vehicles
Definition: map.h:358
std::set< vehicle * > vehicle_list
Definition: map.h:357

References map::access_cache(), map::clear_vehicle_cache(), debugmsg, get_levx(), get_levy(), get_levz(), avatar::grab(), map::has_zlevels(), map::load(), m, level_cache::map_memory_seen_cache, OBJECT_NONE, OVERMAP_DEPTH, OVERMAP_HEIGHT, reload_npcs(), scent_map::reset(), scent, map::set_outside_cache_dirty(), map::set_transparency_cache_dirty(), Character::setz(), shift_monsters(), map::spawn_monsters(), u, validate_mounted_npcs(), level_cache::vehicle_list, vertical_notes(), map::vertical_shift(), and level_cache::zone_vehicles.

Referenced by place_player(), and vertical_move().

◆ walk_move()

bool game::walk_move ( const tripoint dest,
bool  via_ramp = false 
)

TODO: This should really use the mounted creatures stamina, if mounted. Monsters don't currently have stamina however. For the time being just don't burn players stamina when mounted.

Dexterity decreases chance of tentacles getting stuck to the ground Intelligence decreases chance of tentacles getting stuck to the ground

Definition at line 8766 of file game.cpp.

8767{
8768 if( m.has_flag_ter( TFLAG_SMALL_PASSAGE, dest_loc ) ) {
8769 if( u.get_size() > MS_MEDIUM ) {
8770 add_msg( m_warning, _( "You can't fit there." ) );
8771 return false; // character too large to fit through a tight passage
8772 }
8773 if( u.is_mounted() ) {
8774 monster *mount = u.mounted_creature.get();
8775 if( mount->get_size() > MS_MEDIUM ) {
8776 add_msg( m_warning, _( "Your mount can't fit there." ) );
8777 return false; // char's mount is too large for tight passages
8778 }
8779 }
8780 }
8781
8782 if( u.is_mounted() ) {
8783 auto mons = u.mounted_creature.get();
8784 if( mons->has_flag( MF_RIDEABLE_MECH ) ) {
8785 if( !mons->check_mech_powered() ) {
8786 add_msg( m_bad, _( "Your %s refuses to move as its batteries have been drained." ),
8787 mons->get_name() );
8788 return false;
8789 }
8790 }
8791 if( !mons->move_effects( false ) ) {
8792 add_msg( m_bad, _( "You cannot move as your %s isn't able to move." ), mons->get_name() );
8793 return false;
8794 }
8795 }
8796 const optional_vpart_position vp_here = m.veh_at( u.pos() );
8797 const optional_vpart_position vp_there = m.veh_at( dest_loc );
8798
8799 bool pushing = false; // moving -into- grabbed tile; skip check for move_cost > 0
8800 bool pulling = false; // moving -away- from grabbed tile; check for move_cost > 0
8801 bool shifting_furniture = false; // moving furniture and staying still; skip check for move_cost > 0
8802
8803 const tripoint furn_pos = u.pos() + u.grab_point;
8804 const tripoint furn_dest = dest_loc + u.grab_point;
8805
8806 bool grabbed = u.get_grab_type() != OBJECT_NONE;
8807 if( grabbed ) {
8808 const tripoint dp = dest_loc - u.pos();
8809 pushing = dp == u.grab_point;
8810 pulling = dp == -u.grab_point;
8811 }
8812 if( grabbed && dest_loc.z != u.posz() ) {
8813 add_msg( m_warning, _( "You let go of the grabbed object." ) );
8814 grabbed = false;
8815 u.grab( OBJECT_NONE );
8816 }
8817
8818 // Now make sure we're actually holding something
8819 const vehicle *grabbed_vehicle = nullptr;
8820 if( grabbed && u.get_grab_type() == OBJECT_FURNITURE ) {
8821 // We only care about shifting, because it's the only one that can change our destination
8822 if( m.has_furn( u.pos() + u.grab_point ) ) {
8823 shifting_furniture = !pushing && !pulling;
8824 } else {
8825 // We were grabbing a furniture that isn't there
8826 grabbed = false;
8827 }
8828 } else if( grabbed && u.get_grab_type() == OBJECT_VEHICLE ) {
8829 grabbed_vehicle = veh_pointer_or_null( m.veh_at( u.pos() + u.grab_point ) );
8830 if( grabbed_vehicle == nullptr ) {
8831 // We were grabbing a vehicle that isn't there anymore
8832 grabbed = false;
8833 }
8834 } else if( grabbed ) {
8835 // We were grabbing something WEIRD, let's pretend we weren't
8836 grabbed = false;
8837 }
8838 if( u.grab_point != tripoint_zero && !grabbed ) {
8839 add_msg( m_warning, _( "Can't find grabbed object." ) );
8840 u.grab( OBJECT_NONE );
8841 }
8842
8843 if( m.impassable( dest_loc ) && !pushing && !shifting_furniture ) {
8844 if( vp_there && u.mounted_creature && u.mounted_creature->has_flag( MF_RIDEABLE_MECH ) &&
8845 vp_there->vehicle().handle_potential_theft( u ) ) {
8846 tripoint diff = dest_loc - u.pos();
8847 if( diff.x < 0 ) {
8848 diff.x -= 2;
8849 } else if( diff.x > 0 ) {
8850 diff.x += 2;
8851 }
8852 if( diff.y < 0 ) {
8853 diff.y -= 2;
8854 } else if( diff.y > 0 ) {
8855 diff.y += 2;
8856 }
8857 u.mounted_creature->shove_vehicle( dest_loc + diff.xy(),
8858 dest_loc );
8859 }
8860 return false;
8861 }
8862 if( vp_there && !vp_there->vehicle().handle_potential_theft( u ) ) {
8863 return false;
8864 }
8865 if( u.is_mounted() && !pushing && vp_there ) {
8866 add_msg( m_warning, _( "You cannot board a vehicle whilst riding." ) );
8867 return false;
8868 }
8869 u.set_underwater( false );
8870
8871 if( !shifting_furniture && !pushing && is_dangerous_tile( dest_loc ) ) {
8872 std::vector<std::string> harmful_stuff = get_dangerous_tile( dest_loc );
8873 const auto dangerous_terrain_opt = get_option<std::string>( "DANGEROUS_TERRAIN_WARNING_PROMPT" );
8874 const auto harmful_text = enumerate_as_string( harmful_stuff );
8875 const auto warn_msg = [&]( const char *const msg ) {
8876 add_msg( m_warning, msg, harmful_text );
8877 };
8878
8879 if( dangerous_terrain_opt == "IGNORE" ) {
8880 warn_msg( _( "Stepping into that %1$s looks risky, but you enter anyway." ) );
8881 } else if( dangerous_terrain_opt == "ALWAYS" && !prompt_dangerous_tile( dest_loc ) ) {
8882 return true;
8883 } else if( dangerous_terrain_opt == "RUNNING" &&
8884 ( !u.movement_mode_is( CMM_RUN ) || !prompt_dangerous_tile( dest_loc ) ) ) {
8885 warn_msg( _( "Stepping into that %1$s looks risky. Run into it if you wish to enter anyway." ) );
8886 return true;
8887 } else if( dangerous_terrain_opt == "CROUCHING" &&
8888 ( !u.movement_mode_is( CMM_CROUCH ) || !prompt_dangerous_tile( dest_loc ) ) ) {
8889 warn_msg( _( "Stepping into that %1$s looks risky. Crouch and move into it if you wish to enter anyway." ) );
8890 return true;
8891 } else if( dangerous_terrain_opt == "NEVER" && !u.movement_mode_is( CMM_RUN ) ) {
8892 warn_msg( _( "Stepping into that %1$s looks risky. Run into it if you wish to enter anyway." ) );
8893 return true;
8894 }
8895 }
8896 // Used to decide whether to print a 'moving is slow message
8897 const int mcost_from = m.move_cost( u.pos() ); //calculate this _before_ calling grabbed_move
8898
8899 int modifier = 0;
8900 if( grabbed && u.get_grab_type() == OBJECT_FURNITURE && u.pos() + u.grab_point == dest_loc ) {
8901 modifier = -m.furn( dest_loc ).obj().movecost;
8902 }
8903
8904 int multiplier = 1;
8905 if( u.is_on_ground() ) {
8906 multiplier *= 3;
8907 }
8908
8909 const int mcost = m.combined_movecost( u.pos(), dest_loc, grabbed_vehicle, modifier,
8910 via_ramp ) * multiplier;
8911 if( grabbed_move( dest_loc - u.pos() ) ) {
8912 return true;
8913 } else if( mcost == 0 ) {
8914 return false;
8915 }
8916 bool diag = trigdist && u.posx() != dest_loc.x && u.posy() != dest_loc.y;
8917 const int previous_moves = u.moves;
8918 if( u.is_mounted() ) {
8919 auto crit = u.mounted_creature.get();
8920 if( !crit->has_flag( MF_RIDEABLE_MECH ) &&
8921 ( m.has_flag_ter_or_furn( "MOUNTABLE", dest_loc ) ||
8922 m.has_flag_ter_or_furn( "BARRICADABLE_DOOR", dest_loc ) ||
8923 m.has_flag_ter_or_furn( "OPENCLOSE_INSIDE", dest_loc ) ||
8924 m.has_flag_ter_or_furn( "BARRICADABLE_DOOR_DAMAGED", dest_loc ) ||
8925 m.has_flag_ter_or_furn( "BARRICADABLE_DOOR_REINFORCED", dest_loc ) ) ) {
8926 add_msg( m_warning, _( "You cannot pass obstacles whilst mounted." ) );
8927 return false;
8928 }
8929 const double base_moves = u.run_cost( mcost, diag ) * 100.0 / crit->get_speed();
8930 const double encumb_moves = u.get_weight() / 4800.0_gram;
8931 u.moves -= static_cast<int>( std::ceil( base_moves + encumb_moves ) );
8932 if( u.movement_mode_is( CMM_WALK ) ) {
8933 crit->use_mech_power( -2 );
8934 } else if( u.movement_mode_is( CMM_CROUCH ) ) {
8935 crit->use_mech_power( -1 );
8936 } else if( u.movement_mode_is( CMM_RUN ) ) {
8937 crit->use_mech_power( -3 );
8938 }
8939 } else {
8940 u.moves -= u.run_cost( mcost, diag );
8941 /**
8942 TODO:
8943 This should really use the mounted creatures stamina, if mounted.
8944 Monsters don't currently have stamina however.
8945 For the time being just don't burn players stamina when mounted.
8946 */
8947 if( grabbed_vehicle == nullptr || grabbed_vehicle->wheelcache.empty() ) {
8948 //Burn normal amount of stamina if no vehicle grabbed or vehicle lacks wheels
8949 u.burn_move_stamina( previous_moves - u.moves );
8950 } else {
8951 //Burn half as much stamina if vehicle has wheels, without changing move time
8952 u.burn_move_stamina( 0.50 * ( previous_moves - u.moves ) );
8953 }
8954 }
8955 // Max out recoil & reset aim point
8957 u.last_target_pos = std::nullopt;
8958
8959 // Print a message if movement is slow
8960 const int mcost_to = m.move_cost( dest_loc ); //calculate this _after_ calling grabbed_move
8961 const bool fungus = m.has_flag_ter_or_furn( "FUNGUS", u.pos() ) ||
8962 m.has_flag_ter_or_furn( "FUNGUS",
8963 dest_loc ); //fungal furniture has no slowing effect on mycus characters
8964 const bool slowed = ( ( !u.has_trait( trait_PARKOUR ) && ( mcost_to > 2 || mcost_from > 2 ) ) ||
8965 mcost_to > 4 || mcost_from > 4 ) &&
8966 !( u.has_trait( trait_M_IMMUNE ) && fungus );
8967 if( slowed && !u.is_mounted() ) {
8968 // Unless u.pos() has a higher movecost than dest_loc, state that dest_loc is the cause
8969 if( mcost_to >= mcost_from ) {
8970 if( auto displayed_part = vp_there.part_displayed() ) {
8971 add_msg( m_warning, _( "Moving onto this %s is slow!" ),
8972 displayed_part->part().name() );
8973 sfx::do_obstacle( displayed_part->part().info().get_id().str() );
8974 } else {
8975 add_msg( m_warning, _( "Moving onto this %s is slow!" ), m.name( dest_loc ) );
8976 sfx::do_obstacle( m.ter( dest_loc ).id().str() );
8977 }
8978 } else {
8979 if( auto displayed_part = vp_here.part_displayed() ) {
8980 add_msg( m_warning, _( "Moving off of this %s is slow!" ),
8981 displayed_part->part().name() );
8982 sfx::do_obstacle( displayed_part->part().info().get_id().str() );
8983 } else {
8984 add_msg( m_warning, _( "Moving off of this %s is slow!" ), m.name( u.pos() ) );
8985 sfx::do_obstacle( m.ter( u.pos() ).id().str() );
8986 }
8987 }
8988 }
8989 if( !u.is_mounted() && u.has_trait( trait_id( "LEG_TENT_BRACE" ) ) &&
8990 ( !u.footwear_factor() ||
8991 ( u.footwear_factor() == .5 && one_in( 2 ) ) ) ) {
8992 // DX and IN are long suits for Cephalopods,
8993 // so this shouldn't cause too much hardship
8994 // Presumed that if it's swimmable, they're
8995 // swimming and won't stick
8996 ///\EFFECT_DEX decreases chance of tentacles getting stuck to the ground
8997
8998 ///\EFFECT_INT decreases chance of tentacles getting stuck to the ground
8999 if( !m.has_flag( "SWIMMABLE", dest_loc ) && one_in( 80 + u.dex_cur + u.int_cur ) ) {
9000 add_msg( _( "Your tentacles stick to the ground, but you pull them free." ) );
9001 u.mod_fatigue( 1 );
9002 }
9003 }
9004 if( !u.has_artifact_with( AEP_STEALTH ) && !u.has_trait( trait_id( "DEBUG_SILENT" ) ) ) {
9005 int volume = u.is_stealthy() ? 3 : 6;
9006 volume *= u.mutation_value( "noise_modifier" );
9007 if( volume > 0 ) {
9009 volume = 2;
9010 } else if( u.has_bionic( bionic_id( "bio_ankles" ) ) ) {
9011 volume = 12;
9012 }
9013 if( u.movement_mode_is( CMM_RUN ) ) {
9014 volume *= 1.5;
9015 } else if( u.movement_mode_is( CMM_CROUCH ) ) {
9016 volume /= 2;
9017 }
9018 if( u.is_mounted() ) {
9019 auto mons = u.mounted_creature.get();
9020 switch( mons->get_size() ) {
9021 case MS_TINY:
9022 volume = 0; // No sound for the tinies
9023 break;
9024 case MS_SMALL:
9025 volume /= 3;
9026 break;
9027 case MS_MEDIUM:
9028 break;
9029 case MS_LARGE:
9030 volume *= 1.5;
9031 break;
9032 case MS_HUGE:
9033 volume *= 2;
9034 break;
9035 default:
9036 break;
9037 }
9038 if( mons->has_flag( MF_LOUDMOVES ) ) {
9039 volume += 6;
9040 }
9041 sounds::sound( dest_loc, volume, sounds::sound_t::movement, mons->type->get_footsteps(), false,
9042 "none", "none" );
9043 } else {
9044 sounds::sound( dest_loc, volume, sounds::sound_t::movement, _( "footsteps" ), true,
9045 "none", "none" ); // Sound of footsteps may awaken nearby monsters
9046 }
9048 }
9049
9050 if( one_in( 20 ) && u.has_artifact_with( AEP_MOVEMENT_NOISE ) ) {
9051 sounds::sound( u.pos(), 40, sounds::sound_t::movement, _( "a rattling sound." ), true,
9052 "misc", "rattling" );
9053 }
9054 }
9055
9056 if( m.has_flag_ter_or_furn( TFLAG_HIDE_PLACE, dest_loc ) ) {
9057 add_msg( m_good, _( "You are hiding in the %s." ), m.name( dest_loc ) );
9058 }
9059
9060 if( dest_loc != u.pos() ) {
9062 }
9063
9064 tripoint oldpos = u.pos();
9065 point submap_shift = place_player( dest_loc );
9066 point ms_shift = sm_to_ms_copy( submap_shift );
9067 oldpos = oldpos - ms_shift;
9068
9069 if( pulling ) {
9070 const tripoint shifted_furn_pos = furn_pos - ms_shift;
9071 const tripoint shifted_furn_dest = furn_dest - ms_shift;
9072 const time_duration fire_age = m.get_field_age( shifted_furn_pos, fd_fire );
9073 const int fire_intensity = m.get_field_intensity( shifted_furn_pos, fd_fire );
9074 m.remove_field( shifted_furn_pos, fd_fire );
9075 m.set_field_intensity( shifted_furn_dest, fd_fire, fire_intensity );
9076 m.set_field_age( shifted_furn_dest, fd_fire, fire_age );
9077 }
9078
9079 if( u.is_hauling() ) {
9080 start_hauling( oldpos );
9081 }
9082
9084
9085 return true;
9086}
void burn_move_stamina(int moves)
Definition: character.cpp:7105
bool is_stealthy() const
Returns true if the player has stealthy movement.
virtual bool has_artifact_with(art_effect_passive effect) const
Definition: character.cpp:3204
units::mass get_weight() const override
Returns body weight plus weight of inventory and worn/wielded items.
Definition: character.cpp:3678
bool is_on_ground() const override
Returns true if the player is knocked over or has broken legs.
Definition: character.cpp:894
float mutation_value(const std::string &val) const
Goes over all mutations, gets min and max of a value with given name.
Definition: character.cpp:6631
int run_cost(int base_cost, bool diag=false) const
Returns the player's modified base movement cost.
m_size get_size() const override
Get size class of character.
Definition: character.cpp:572
bool grabbed_move(const tripoint &dp)
Check for dangerous stuff at dest_loc, return false if the player decides not to step there.
Definition: game.cpp:9692
bool is_dangerous_tile(const tripoint &dest_loc) const
Definition: game.cpp:8695
int combined_movecost(const tripoint &from, const tripoint &to, const vehicle *ignored_vehicle=nullptr, int modifier=0, bool flying=false, bool via_ramp=false) const
Cost to move out of one tile and into the next.
Definition: map.cpp:1902
m_size get_size() const override
Definition: monster.cpp:2729
std::optional< vpart_reference > part_displayed() const
Definition: vehicle.cpp:2499
std::optional< tripoint > last_target_pos
Definition: player.h:242
const std::string & str() const
Returns the identifier as plain std::string.
Definition: string_id.h:255
@ MS_TINY
Definition: creature.h:58
@ MS_LARGE
Definition: creature.h:61
@ MS_MEDIUM
Definition: creature.h:60
static const itype_id itype_rm13_armor_on("rm13_armor_on")
static const trait_id trait_M_IMMUNE("M_IMMUNE")
@ TFLAG_SMALL_PASSAGE
Definition: mapdata.h:320
@ TFLAG_HIDE_PLACE
Definition: mapdata.h:315
@ MF_LOUDMOVES
Definition: mtype.h:175
void fungus(player &p, const tripoint &examp)
Remove furniture.
Definition: iexamine.cpp:2224
void do_obstacle(const std::string &obst="")
Definition: sounds.cpp:1633
void do_footstep()
Definition: sounds.cpp:1610

References _, add_msg(), AEP_MOVEMENT_NOISE, AEP_STEALTH, cata_event_dispatch::avatar_moves(), Character::burn_move_stamina(), CMM_CROUCH, CMM_RUN, CMM_WALK, map::combined_movecost(), Character::dex_cur, sfx::do_footstep(), sfx::do_obstacle(), enumerate_as_string(), fd_fire, Character::footwear_factor(), iexamine::fungus(), map::furn(), get_dangerous_tile(), map::get_field_age(), map::get_field_intensity(), avatar::get_grab_type(), Character::get_size(), monster::get_size(), Character::get_weight(), avatar::grab(), player::grab_point, grabbed_move(), Character::has_artifact_with(), Character::has_bionic(), map::has_flag(), map::has_flag_ter(), map::has_flag_ter_or_furn(), map::has_furn(), Character::has_trait(), int_id< T >::id(), map::impassable(), Character::int_cur, is_dangerous_tile(), Character::is_hauling(), Character::is_mounted(), Character::is_on_ground(), Character::is_stealthy(), Character::is_wearing(), itype_rm13_armor_on, player::last_target_pos, m, m_bad, m_good, m_warning, MAX_RECOIL, MF_LOUDMOVES, MF_RIDEABLE_MECH, Character::mod_fatigue(), Character::mounted_creature, map::move_cost(), map_data_common_t::movecost, sounds::movement, Character::movement_mode_is(), Creature::moves, MS_HUGE, MS_LARGE, MS_MEDIUM, MS_SMALL, MS_TINY, Character::mutation_value(), map::name(), int_id< T >::obj(), OBJECT_FURNITURE, OBJECT_NONE, OBJECT_VEHICLE, on_move_effects(), one_in(), optional_vpart_position::part_displayed(), place_player(), Character::pos(), Character::posx(), Character::posy(), Character::posz(), prompt_dangerous_tile(), Character::recoil, map::remove_field(), Character::run_cost(), map::set_field_age(), map::set_field_intensity(), Character::set_underwater(), sm_to_ms_copy(), sounds::sound(), start_hauling(), string_id< T >::str(), map::ter(), TFLAG_HIDE_PLACE, TFLAG_SMALL_PASSAGE, trait_M_IMMUNE, trait_PARKOUR, trigdist, tripoint_zero, u, map::veh_at(), veh_pointer_or_null(), vehicle::wheelcache, tripoint::x, tripoint::xy(), tripoint::y, and tripoint::z.

Referenced by swap_critters().

◆ win()

void game::win ( )

Marks the game as won.

Doesn't end the game.

Definition at line 2439 of file game.cpp.

2440{
2441 win_screen();
2443 memorial().add(
2444 pgettext( "memorial_male", "Closed the portal in %1$.1f days (%2$d seconds)." ),
2445 pgettext( "memorial_female", "Closed the portal in %1$.1f days (%2$d seconds)." ),
2446 to_days<float>( game_duration ), to_seconds<int>( game_duration ) );
2447 if( !u.is_dead_state() ) {
2450 }
2451}
void win_screen()
Definition: game.cpp:2453
void add(const std::string &male_msg, const std::string &female_msg)
Adds an event to the memorial log, to be written to the memorial file when the character dies.
const time_point & start_of_game
Definition: calendar.cpp:34

References achievements_tracker_ptr, memorial_logger::add(), Messages::display_messages(), get_kill_tracker(), Character::is_dead_state(), memorial(), pgettext(), show_scores_ui(), calendar::start_of_game, stats(), calendar::turn, u, and win_screen().

◆ win_screen()

void game::win_screen ( )
private

Definition at line 2453 of file game.cpp.

2454{
2455 // TODO: Move this wall somewhere
2457 std::string msg = _( "You managed to close the portal and end the invasion!" );
2458 msg += '\n';
2459 if( u.is_dead_state() ) {
2461 "Unfortunately, you had to sacrifice your life to achieve this." );
2462 msg += colorize( t, c_red ) + '\n';
2463 memorial().add(
2464 pgettext( "memorial_male", "Sacrificed his life to close the portal." ),
2465 pgettext( "memorial_female", "Sacrificed her life to close the portal." ) );
2466 } else {
2467 translation t = translation::to_translation( "win_game", "You managed to survive the ordeal." );
2468 msg += colorize( t, c_green ) + '\n';
2469 memorial().add(
2470 pgettext( "memorial_male", "Safely closed the portal." ),
2471 pgettext( "memorial_female", "Safely closed the portal." ) );
2472 }
2473 msg += string_format( _( "It took you %1$.1f days (%2$d seconds)." ),
2474 to_days<float>( game_duration ), to_seconds<int>( game_duration ) );
2475 // TODO: Print starting stats, traits, skills, all mods ever used, easiest of settings
2476 popup( msg );
2477}
Class for storing translation context and raw string for deferred translation.
Definition: translations.h:152
static translation to_translation(const std::string &raw)
Store a string, an optional plural form, and an optional context for translation.

References _, memorial_logger::add(), c_green, c_red, colorize(), Character::is_dead_state(), memorial(), pgettext(), popup(), calendar::start_of_game, string_format(), translation::to_translation(), calendar::turn, and u.

Referenced by win().

◆ write_memorial_file()

void game::write_memorial_file ( const std::string &  filename,
std::string  sLastWords 
)

Writes information about the character out to a text file timestamped with the time of the file was made.

This serves as a record of the character's state at the time the memorial was made (usually upon death) and accomplishments in a human-readable format.

Definition at line 2780 of file game.cpp.

2781{
2782 const std::string &memorial_dir = PATH_INFO::memorialdir();
2783 const std::string &memorial_active_world_dir = memorial_dir +
2784 world_generator->active_world->world_name + "/";
2785
2786 //Check if both dirs exist. Nested assure_dir_exist fails if the first dir of the nested dir does not exist.
2787 if( !assure_dir_exist( memorial_dir ) ) {
2788 debugmsg( "Could not make '%s' directory", memorial_dir );
2789 return;
2790 }
2791
2792 if( !assure_dir_exist( memorial_active_world_dir ) ) {
2793 debugmsg( "Could not make '%s' directory", memorial_active_world_dir );
2794 return;
2795 }
2796
2797 std::string path = memorial_active_world_dir + filename + ".txt";
2798
2799 write_to_file( path, [&]( std::ostream & fout ) {
2800 memorial().write( fout, sLastWords );
2801 }, _( "player memorial" ) );
2802}
void write(std::ostream &memorial_file, const std::string &epitaph) const
std::string memorialdir()
Definition: path_info.cpp:222

References _, assure_dir_exist(), debugmsg, memorial(), PATH_INFO::memorialdir(), world_generator, memorial_logger::write(), and write_to_file().

Referenced by cleanup_at_end().

◆ zones_manager()

void game::zones_manager ( )

Definition at line 6100 of file game.cpp.

6101{
6102 const tripoint stored_view_offset = u.view_offset;
6103
6105
6106 const int zone_ui_height = 12;
6107 const int zone_options_height = 7;
6108
6109 const int width = 45;
6110
6111 int offsetX = 0;
6112 int max_rows = 0;
6113
6114 catacurses::window w_zones;
6115 catacurses::window w_zones_border;
6116 catacurses::window w_zones_info;
6117 catacurses::window w_zones_info_border;
6118 catacurses::window w_zones_options;
6119
6120 bool show = true;
6121
6122 ui_adaptor ui;
6123 ui.on_screen_resize( [&]( ui_adaptor & ui ) {
6124 if( !show ) {
6125 ui.position( point_zero, point_zero );
6126 return;
6127 }
6128 offsetX = get_option<std::string>( "SIDEBAR_POSITION" ) != "left" ?
6129 TERMX - width : 0;
6130 const int w_zone_height = TERMY - zone_ui_height;
6131 max_rows = w_zone_height - 2;
6132 w_zones = catacurses::newwin( w_zone_height - 2, width - 2,
6133 point( offsetX + 1, 1 ) );
6134 w_zones_border = catacurses::newwin( w_zone_height, width,
6135 point( offsetX, 0 ) );
6136 w_zones_info = catacurses::newwin( zone_ui_height - zone_options_height - 1,
6137 width - 2, point( offsetX + 1, w_zone_height ) );
6138 w_zones_info_border = catacurses::newwin( zone_ui_height, width,
6139 point( offsetX, w_zone_height ) );
6140 w_zones_options = catacurses::newwin( zone_options_height - 1, width - 2,
6141 point( offsetX + 1, TERMY - zone_options_height ) );
6142
6143 ui.position( point( offsetX, 0 ), point( width, TERMY ) );
6144 } );
6145 ui.mark_resize();
6146
6147 std::string action;
6148 input_context ctxt( "ZONES_MANAGER" );
6149 ctxt.register_cardinal();
6150 ctxt.register_action( "CONFIRM" );
6151 ctxt.register_action( "QUIT" );
6152 ctxt.register_action( "ADD_ZONE" );
6153 ctxt.register_action( "REMOVE_ZONE" );
6154 ctxt.register_action( "MOVE_ZONE_UP" );
6155 ctxt.register_action( "MOVE_ZONE_DOWN" );
6156 ctxt.register_action( "SHOW_ZONE_ON_MAP" );
6157 ctxt.register_action( "ENABLE_ZONE" );
6158 ctxt.register_action( "DISABLE_ZONE" );
6159 ctxt.register_action( "SHOW_ALL_ZONES" );
6160 ctxt.register_action( "HELP_KEYBINDINGS" );
6161
6162 auto &mgr = zone_manager::get_manager();
6163 int start_index = 0;
6164 int active_index = 0;
6165 bool blink = false;
6166 bool stuff_changed = false;
6167 bool show_all_zones = false;
6168 int zone_cnt = 0;
6169
6170 // get zones on the same z-level, with distance between player and
6171 // zone center point <= 50 or all zones, if show_all_zones is true
6172 auto get_zones = [&]() {
6173 std::vector<zone_manager::ref_zone_data> zones;
6174 if( show_all_zones ) {
6175 zones = mgr.get_zones();
6176 } else {
6177 const tripoint &u_abs_pos = m.getabs( u.pos() );
6178 for( zone_manager::ref_zone_data &ref : mgr.get_zones() ) {
6179 const tripoint &zone_abs_pos = ref.get().get_center_point();
6180 if( u_abs_pos.z == zone_abs_pos.z && rl_dist( u_abs_pos, zone_abs_pos ) <= 50 ) {
6181 zones.emplace_back( ref );
6182 }
6183 }
6184 }
6185 zone_cnt = static_cast<int>( zones.size() );
6186 return zones;
6187 };
6188
6189 auto zones = get_zones();
6190
6191 auto zones_manager_options = [&]() {
6192 werase( w_zones_options );
6193
6194 if( zone_cnt > 0 ) {
6195 const auto &zone = zones[active_index].get();
6196
6197 if( zone.has_options() ) {
6198 const auto &descriptions = zone.get_options().get_descriptions();
6199
6200 // NOLINTNEXTLINE(cata-use-named-point-constants)
6201 mvwprintz( w_zones_options, point( 1, 0 ), c_white, _( "Options" ) );
6202
6203 int y = 1;
6204 for( const auto &desc : descriptions ) {
6205 mvwprintz( w_zones_options, point( 3, y ), c_white, desc.first );
6206 mvwprintz( w_zones_options, point( 20, y ), c_white, desc.second );
6207 y++;
6208 }
6209 }
6210 }
6211
6212 wnoutrefresh( w_zones_options );
6213 };
6214
6215 std::optional<tripoint> zone_start;
6216 std::optional<tripoint> zone_end;
6217 bool zone_blink = false;
6218 bool zone_cursor = false;
6220 zone_start, zone_end, zone_blink, zone_cursor );
6221 add_draw_callback( zone_cb );
6222
6223 auto query_position =
6224 [&]() -> std::optional<std::pair<tripoint, tripoint>> {
6225 on_out_of_scope invalidate_current_ui( [&]()
6226 {
6227 ui.mark_resize();
6228 } );
6229 restore_on_out_of_scope<bool> show_prev( show );
6230 restore_on_out_of_scope<std::optional<tripoint>> zone_start_prev( zone_start );
6231 restore_on_out_of_scope<std::optional<tripoint>> zone_end_prev( zone_end );
6232 show = false;
6233 zone_start = std::nullopt;
6234 zone_end = std::nullopt;
6235 ui.mark_resize();
6236
6238 popup.on_top( true );
6239 popup.message( "%s", _( "Select first point." ) );
6240
6242
6243 const look_around_result first = look_around( /*show_window=*/false, center, center, false, true,
6244 false );
6245 if( first.position )
6246 {
6247 popup.message( "%s", _( "Select second point." ) );
6248
6249 const look_around_result second = look_around( /*show_window=*/false, center, *first.position,
6250 true, true, false );
6251 if( second.position ) {
6252 tripoint first_abs = m.getabs( tripoint( std::min( first.position->x,
6253 second.position->x ),
6254 std::min( first.position->y, second.position->y ),
6255 std::min( first.position->z,
6256 second.position->z ) ) );
6257 tripoint second_abs = m.getabs( tripoint( std::max( first.position->x,
6258 second.position->x ),
6259 std::max( first.position->y, second.position->y ),
6260 std::max( first.position->z,
6261 second.position->z ) ) );
6262 return std::pair<tripoint, tripoint>( first_abs, second_abs );
6263 }
6264 }
6265
6266 return std::nullopt;
6267 };
6268
6269 ui.on_redraw( [&]( const ui_adaptor & ) {
6270 if( !show ) {
6271 return;
6272 }
6273 zones_manager_draw_borders( w_zones_border, w_zones_info_border, zone_ui_height, width );
6274 zones_manager_shortcuts( w_zones_info );
6275
6276 if( zone_cnt == 0 ) {
6277 werase( w_zones );
6278 mvwprintz( w_zones, point( 2, 5 ), c_white, _( "No Zones defined." ) );
6279
6280 } else {
6281 werase( w_zones );
6282
6283 calcStartPos( start_index, active_index, max_rows, zone_cnt );
6284
6285 draw_scrollbar( w_zones_border, active_index, max_rows, zone_cnt, point_south );
6286 wnoutrefresh( w_zones_border );
6287
6288 int iNum = 0;
6289
6290 tripoint player_absolute_pos = m.getabs( u.pos() );
6291
6292 //Display saved zones
6293 for( auto &i : zones ) {
6294 if( iNum >= start_index &&
6295 iNum < start_index + ( ( max_rows > zone_cnt ) ? zone_cnt : max_rows ) ) {
6296 const auto &zone = i.get();
6297
6298 nc_color colorLine = ( zone.get_enabled() ) ? c_white : c_light_gray;
6299
6300 if( iNum == active_index ) {
6301 mvwprintz( w_zones, point( 0, iNum - start_index ), c_yellow, "%s", ">>" );
6302 colorLine = ( zone.get_enabled() ) ? c_light_green : c_green;
6303 }
6304
6305 //Draw Zone name
6306 mvwprintz( w_zones, point( 3, iNum - start_index ), colorLine,
6307 trim_by_length( zone.get_name(), 15 ) );
6308
6309 //Draw Type name
6310 mvwprintz( w_zones, point( 20, iNum - start_index ), colorLine,
6311 mgr.get_name_from_type( zone.get_type() ) );
6312
6313 tripoint center = zone.get_center_point();
6314
6315 //Draw direction + distance
6316 mvwprintz( w_zones, point( 32, iNum - start_index ), colorLine, "%*d %s",
6317 5, static_cast<int>( trig_dist( player_absolute_pos, center ) ),
6318 direction_name_short( direction_from( player_absolute_pos,
6319 center ) ) );
6320
6321 //Draw Vehicle Indicator
6322 mvwprintz( w_zones, point( 41, iNum - start_index ), colorLine,
6323 zone.get_is_vehicle() ? "*" : "" );
6324 }
6325 iNum++;
6326 }
6327
6328 // Display zone options
6329 zones_manager_options();
6330 }
6331
6332 wnoutrefresh( w_zones );
6333 } );
6334
6335 zones_manager_open = true;
6336 do {
6337 if( action == "ADD_ZONE" ) {
6338 do { // not a loop, just for quick bailing out if canceled
6339 const auto maybe_id = mgr.query_type();
6340 if( !maybe_id.has_value() ) {
6341 break;
6342 }
6343
6344 const zone_type_id &id = maybe_id.value();
6345 auto options = zone_options::create( id );
6346
6347 if( !options->query_at_creation() ) {
6348 break;
6349 }
6350
6351 auto default_name = options->get_zone_name_suggestion();
6352 if( default_name.empty() ) {
6353 default_name = mgr.get_name_from_type( id );
6354 }
6355 const auto maybe_name = mgr.query_name( default_name );
6356 if( !maybe_name.has_value() ) {
6357 break;
6358 }
6359 const std::string &name = maybe_name.value();
6360
6361 const auto position = query_position();
6362 if( !position ) {
6363 break;
6364 }
6365
6366 mgr.add( name, id, g->u.get_faction()->id, false, true, position->first,
6367 position->second, options );
6368
6369 zones = get_zones();
6370 active_index = zone_cnt - 1;
6371
6372 stuff_changed = true;
6373 } while( false );
6374
6375 blink = false;
6376 } else if( action == "SHOW_ALL_ZONES" ) {
6377 show_all_zones = !show_all_zones;
6378 zones = get_zones();
6379 active_index = 0;
6380 } else if( zone_cnt > 0 ) {
6381 if( action == "UP" ) {
6382 active_index--;
6383 if( active_index < 0 ) {
6384 active_index = zone_cnt - 1;
6385 }
6386 blink = false;
6387 } else if( action == "DOWN" ) {
6388 active_index++;
6389 if( active_index >= zone_cnt ) {
6390 active_index = 0;
6391 }
6392 blink = false;
6393 } else if( action == "REMOVE_ZONE" ) {
6394 if( active_index < zone_cnt ) {
6395 mgr.remove( zones[active_index] );
6396 zones = get_zones();
6397 active_index--;
6398
6399 if( active_index < 0 ) {
6400 active_index = 0;
6401 }
6402 }
6403 blink = false;
6404 stuff_changed = true;
6405
6406 } else if( action == "CONFIRM" ) {
6407 auto &zone = zones[active_index].get();
6408
6409 uilist as_m;
6410 as_m.text = _( "What do you want to change:" );
6411 as_m.entries.emplace_back( 1, true, '1', _( "Edit name" ) );
6412 as_m.entries.emplace_back( 2, true, '2', _( "Edit type" ) );
6413 as_m.entries.emplace_back( 3, zone.get_options().has_options(), '3',
6414 zone.get_type() == zone_type_id( "LOOT_CUSTOM" ) ? _( "Edit filter" ) : _( "Edit options" ) );
6415 as_m.entries.emplace_back( 4, !zone.get_is_vehicle(), '4', _( "Edit position" ) );
6416 // TODO: Enable moving vzone after vehicle zone can be bigger than 1*1
6417 as_m.entries.emplace_back( 5, !zone.get_is_vehicle(), '5', _( "Move position" ) );
6418 as_m.query();
6419
6420 switch( as_m.ret ) {
6421 case 1:
6422 if( zone.set_name() ) {
6423 stuff_changed = true;
6424 }
6425 break;
6426 case 2:
6427 if( zone.set_type() ) {
6428 stuff_changed = true;
6429 }
6430 break;
6431 case 3:
6432 if( zone.get_options().query() ) {
6433 stuff_changed = true;
6434 }
6435 break;
6436 case 4: {
6437 const auto pos = query_position();
6438 if( pos && ( pos->first != zone.get_start_point() ||
6439 pos->second != zone.get_end_point() ) ) {
6440 zone.set_position( *pos );
6441 stuff_changed = true;
6442 }
6443 break;
6444 }
6445 case 5: {
6446 on_out_of_scope invalidate_current_ui( [&]() {
6447 ui.mark_resize();
6448 } );
6449 restore_on_out_of_scope<bool> show_prev( show );
6450 restore_on_out_of_scope<std::optional<tripoint>> zone_start_prev( zone_start );
6451 restore_on_out_of_scope<std::optional<tripoint>> zone_end_prev( zone_end );
6452 show = false;
6453 zone_start = std::nullopt;
6454 zone_end = std::nullopt;
6455 ui.mark_resize();
6456 static_popup message_pop;
6457 message_pop.on_top( true );
6458 message_pop.message( "%s", _( "Moving zone." ) );
6459 const auto zone_local_start_point = m.getlocal( zone.get_start_point() );
6460 const auto zone_local_end_point = m.getlocal( zone.get_end_point() );
6461 // local position of the zone center, used to calculate the u.view_offset,
6462 // could center the screen to the position it represents
6463 auto view_center = m.getlocal( zone.get_center_point() );
6464 const look_around_result result_local = look_around( false, view_center,
6465 zone_local_start_point, false, false,
6466 false, true, zone_local_end_point );
6467 if( result_local.position ) {
6468 const auto new_start_point = m.getabs( *result_local.position );
6469 if( new_start_point == zone.get_start_point() ) {
6470 break; // Nothing changed, don't save
6471 }
6472
6473 const auto new_end_point = zone.get_end_point() - zone.get_start_point() + new_start_point;
6474 zone.set_position( std::pair<tripoint, tripoint>( new_start_point, new_end_point ) );
6475 stuff_changed = true;
6476 }
6477 }
6478 break;
6479 default:
6480 break;
6481 }
6482
6483 blink = false;
6484 } else if( action == "MOVE_ZONE_UP" && zone_cnt > 1 ) {
6485 if( active_index < zone_cnt - 1 ) {
6486 mgr.swap( zones[active_index], zones[active_index + 1] );
6487 zones = get_zones();
6488 active_index++;
6489 }
6490 blink = false;
6491 stuff_changed = true;
6492
6493 } else if( action == "MOVE_ZONE_DOWN" && zone_cnt > 1 ) {
6494 if( active_index > 0 ) {
6495 mgr.swap( zones[active_index], zones[active_index - 1] );
6496 zones = get_zones();
6497 active_index--;
6498 }
6499 blink = false;
6500 stuff_changed = true;
6501
6502 } else if( action == "SHOW_ZONE_ON_MAP" ) {
6503 //show zone position on overmap;
6504 tripoint_abs_omt player_overmap_position = u.global_omt_location();
6505 // TODO: fix point types
6506 tripoint_abs_omt zone_overmap( ms_to_omt_copy( zones[active_index].get().get_center_point() ) );
6507
6508 ui::omap::display_zones( player_overmap_position, zone_overmap, active_index );
6509 } else if( action == "ENABLE_ZONE" ) {
6510 zones[active_index].get().set_enabled( true );
6511
6512 stuff_changed = true;
6513
6514 } else if( action == "DISABLE_ZONE" ) {
6515 zones[active_index].get().set_enabled( false );
6516
6517 stuff_changed = true;
6518 }
6519 }
6520
6521 if( zone_cnt > 0 ) {
6522 blink = !blink;
6523 const auto &zone = zones[active_index].get();
6524 zone_start = m.getlocal( zone.get_start_point() );
6525 zone_end = m.getlocal( zone.get_end_point() );
6526 ctxt.set_timeout( get_option<int>( "BLINK_SPEED" ) );
6527 } else {
6528 blink = false;
6529 zone_start = zone_end = std::nullopt;
6530 ctxt.reset_timeout();
6531 }
6532
6533 // Actually accessed from the terrain overlay callback `zone_cb` in the
6534 // call to `ui_manager::redraw`.
6535 //NOLINTNEXTLINE(clang-analyzer-deadcode.DeadStores)
6536 zone_blink = blink;
6538
6540
6541 //Wait for input
6542 action = ctxt.handle_input();
6543 } while( action != "QUIT" );
6544 zones_manager_open = false;
6545 ctxt.reset_timeout();
6546 zone_cb = nullptr;
6547
6548 if( stuff_changed ) {
6549 auto &zones = zone_manager::get_manager();
6550 if( query_yn( _( "Save changes?" ) ) ) {
6551 zones.save_zones();
6552 } else {
6553 zones.load_zones();
6554 }
6555
6556 zones.cache_data();
6557 }
6558
6559 u.view_offset = stored_view_offset;
6560}
query_popup & on_top(bool top)
Whether to show the popup on the top of the screen.
Definition: popup.cpp:59
std::reference_wrapper< zone_data > ref_zone_data
Definition: clzones.h:342
static shared_ptr_fast< zone_options > create(const zone_type_id &type)
Definition: clzones.cpp:186
int trig_dist(const coords::coord_point< Point, Origin, Scale > &loc1, const coords::coord_point< Point, Origin, Scale > &loc2)
Definition: coordinates.h:512
static void zones_manager_shortcuts(const catacurses::window &w_info)
Definition: game.cpp:6035
static void zones_manager_draw_borders(const catacurses::window &w_border, const catacurses::window &w_info_border, const int iInfoHeight, const int width)
Definition: game.cpp:6058
void optional(const JsonObject &jo, const bool was_loaded, const std::string &name, MemberType &member)
std::string options()
Definition: path_info.cpp:230
const std::set< itype_id > & get()
void display_zones(const tripoint_abs_omt &center, const tripoint_abs_omt &select, int iZoneIndex)
Display overmap like with display() and display the given zone.
std::string trim_by_length(const std::string &text, int width)
Definition: output.cpp:224
std::optional< tripoint > position
Definition: game.h:127

References _, action, add_draw_callback(), c_green, c_light_gray, c_light_green, c_white, c_yellow, calcStartPos(), center, zone_options::create(), create_zone_callback(), direction_from(), direction_name_short(), ui::omap::display_zones(), draw_scrollbar(), uilist::entries, g, charge_removal_blacklist::get(), zone_manager::get_manager(), map::getabs(), map::getlocal(), Character::global_omt_location(), input_context::handle_input(), invalidate_main_ui_adaptor(), look_around(), m, query_popup::message(), ms_to_omt_copy(), mvwprintz(), om_direction::name(), catacurses::newwin(), query_popup::on_top(), optional(), PATH_INFO::options(), point_south, point_zero, popup(), Character::pos(), look_around_result::position, uilist::query(), query_yn(), ui_manager::redraw(), input_context::register_action(), input_context::register_cardinal(), input_context::reset_timeout(), uilist::ret, rl_dist(), second, input_context::set_timeout(), TERMX, TERMY, uilist::text, trig_dist(), trim_by_length(), tripoint_zero, u, player::view_offset, catacurses::werase(), catacurses::wnoutrefresh(), tripoint::z, zones_manager_draw_borders(), zones_manager_open, and zones_manager_shortcuts().

Referenced by handle_action().

◆ zoom_in()

void game::zoom_in ( )

Definition at line 7062 of file game.cpp.

7063{
7064#if defined(TILES)
7065 if( tileset_zoom == 64 ) {
7066 tileset_zoom = MAXIMUM_ZOOM_LEVEL;
7067 } else {
7069 }
7070 rescale_tileset( tileset_zoom );
7071#endif
7072}

References tileset_zoom.

Referenced by handle_action(), and look_around().

◆ zoom_out()

void game::zoom_out ( )

Definition at line 7050 of file game.cpp.

7051{
7052#if defined(TILES)
7053 if( tileset_zoom > MAXIMUM_ZOOM_LEVEL ) {
7055 } else {
7056 tileset_zoom = 64;
7057 }
7058 rescale_tileset( tileset_zoom );
7059#endif
7060}

References tileset_zoom.

Referenced by handle_action(), and look_around().

Friends And Related Function Documentation

◆ advanced_inventory

friend class advanced_inventory
friend

Definition at line 146 of file game.h.

◆ Creature_range

friend class Creature_range
friend

Definition at line 334 of file game.h.

Referenced by all_creatures().

◆ editmap

friend class editmap
friend

Definition at line 145 of file game.h.

◆ get_avatar

avatar & get_avatar ( )
friend

Definition at line 104 of file avatar.cpp.

105{
106 return g->u;
107}

Referenced by butcher_submenu(), and get_player_base_save_path().

◆ get_distribution_grid_tracker

distribution_grid_tracker & get_distribution_grid_tracker ( )
friend

Returns distribution grid tracker that is a part of the global game *g.

game TODO: This wouldn't be required in an ideal world

Definition at line 12076 of file game.cpp.

12077{
12078 return *g->grid_tracker_ptr;
12079}

◆ get_map

map & get_map ( )
friend

◆ get_player_character

Character & get_player_character ( )
friend

Definition at line 400 of file character.cpp.

401{
402 return g->u;
403}

◆ get_weather

weather_manager & get_weather ( )
friend

Definition at line 64 of file weather.cpp.

65{
66 return *g->weather_manager_ptr;
67}

Referenced by do_turn(), get_player_input(), is_in_sunlight(), load(), natural_light_level(), place_player_overmap(), serialize_master(), setup(), start_game(), and unserialize_master().

◆ main_menu

friend class main_menu
friend

Definition at line 147 of file game.h.

◆ monster_range

friend class monster_range
friend

Definition at line 333 of file game.h.

Referenced by all_monsters().

Member Data Documentation

◆ achievements_tracker_ptr

pimpl<achievements_tracker> game::achievements_tracker_ptr
private

Definition at line 954 of file game.h.

Referenced by death_screen(), game(), handle_action(), serialize(), setup(), unserialize(), and win().

◆ active_npc

◆ auto_travel_mode

bool game::auto_travel_mode = false

Definition at line 1017 of file game.h.

Referenced by handle_action(), serialize(), and unserialize().

◆ bVMonsterLookFire

bool game::bVMonsterLookFire = false
private

Definition at line 1034 of file game.h.

Referenced by list_monsters(), look_around(), and setup().

◆ coming_to_stairs

std::vector<monster> game::coming_to_stairs

◆ critter_died

bool game::critter_died = false
private

Has anything died in this turn and needs to be cleaned up?

Definition at line 1048 of file game.h.

Referenced by cleanup_dead(), and set_critter_died().

◆ critter_tracker

◆ debug_hour_timer

◆ debug_pathfinding

bool game::debug_pathfinding = false

Definition at line 998 of file game.h.

◆ debug_submap_grid_overlay

bool game::debug_submap_grid_overlay = false

Definition at line 999 of file game.h.

◆ destination_preview

std::vector<tripoint> game::destination_preview
private

◆ displaying_lighting_condition

int game::displaying_lighting_condition = 0

Type of lighting condition overlay to display.

Definition at line 1011 of file game.h.

◆ displaying_overlays

std::optional<action_id> game::displaying_overlays
private

Definition at line 918 of file game.h.

Referenced by display_overlay_state(), and display_toggle_overlay().

◆ displaying_visibility_creature

Creature* game::displaying_visibility_creature

Creature for which to display the visibility map.

Definition at line 1009 of file game.h.

Referenced by display_visibility().

◆ draw_callbacks

std::vector<weak_ptr_fast<draw_callback_t> > game::draw_callbacks
private

Definition at line 225 of file game.h.

Referenced by add_draw_callback(), and draw().

◆ driving_view_offset

point game::driving_view_offset

Definition at line 996 of file game.h.

Referenced by calc_driving_offset(), do_turn(), handle_action(), and set_driving_view_offset().

◆ event_bus_ptr

pimpl<event_bus> game::event_bus_ptr
private

Definition at line 952 of file game.h.

Referenced by events().

◆ faction_manager_ptr

◆ first_redraw_since_waiting_started

bool game::first_redraw_since_waiting_started = true
private

Is this the first redraw since waiting (sleeping or activity) started.

Definition at line 1050 of file game.h.

Referenced by do_turn(), and game().

◆ follower_ids

std::set<character_id> game::follower_ids
private

◆ fullscreen

bool game::fullscreen = false

◆ gamemode

std::unique_ptr<special_game> game::gamemode
private

◆ grid_tracker_ptr

pimpl<distribution_grid_tracker> game::grid_tracker_ptr
private

Definition at line 958 of file game.h.

Referenced by do_turn(), load_map(), on_options_changed(), and update_map().

◆ is_looking

bool game::is_looking = false
private

Definition at line 224 of file game.h.

Referenced by draw_ter(), and look_around().

◆ kill_tracker_ptr

pimpl<kill_tracker> game::kill_tracker_ptr
private

Definition at line 955 of file game.h.

Referenced by game(), get_kill_tracker(), serialize(), setup(), and unserialize().

◆ last_mouse_edge_scroll

std::chrono::time_point<std::chrono::steady_clock> game::last_mouse_edge_scroll
private

Definition at line 1067 of file game.h.

Referenced by mouse_edge_scrolling().

◆ last_mouse_edge_scroll_vector_overmap

tripoint game::last_mouse_edge_scroll_vector_overmap
private

Definition at line 1069 of file game.h.

Referenced by mouse_edge_scrolling_overmap(), and mouse_edge_scrolling_terrain().

◆ last_mouse_edge_scroll_vector_terrain

tripoint game::last_mouse_edge_scroll_vector_terrain
private

Definition at line 1068 of file game.h.

Referenced by mouse_edge_scrolling_overmap(), and mouse_edge_scrolling_terrain().

◆ last_save_timestamp

time_t game::last_save_timestamp
private

Definition at line 1040 of file game.h.

Referenced by autosave(), init_autosave(), and quicksave().

◆ latest_lightlevels

std::array<float, OVERMAP_LAYERS> game::latest_lightlevels
mutableprivate

Definition at line 1041 of file game.h.

Referenced by natural_light_level(), and reset_light_level().

◆ list_item_downvote

std::string game::list_item_downvote
private

Definition at line 1031 of file game.h.

Referenced by list_items().

◆ list_item_upvote

std::string game::list_item_upvote
private

Definition at line 1030 of file game.h.

Referenced by list_items().

◆ liveview

live_view& game::liveview
private

Definition at line 949 of file game.h.

Referenced by draw_look_around_cursor(), and handle_mouseview().

◆ liveview_ptr

pimpl<live_view> game::liveview_ptr
private

Definition at line 948 of file game.h.

◆ m

map& game::m

Definition at line 962 of file game.h.

Referenced by autopilot_vehicles(), cata_event_dispatch::avatar_moves(), butcher(), catch_a_monster(), chat(), check_near_zone(), check_zone(), control_vehicle(), delete_cyborg_item(), disable_robot(), disp_NPCs(), do_turn(), draw(), draw_bullet(), draw_critter(), draw_critter_highlighted(), draw_critter_internal(), draw_hit_mon(), draw_look_around_cursor(), draw_ter(), examine(), extended_description(), find_nearby_items(), find_or_make_stairs(), fling_creature(), forced_door_closing(), get_cur_om(), get_dangerous_tile(), get_fishable_locations(), get_levx(), get_levy(), get_levz(), get_player_input(), get_veh_dir_indicator_location(), grabbed_furn_move(), grabbed_veh_move(), handle_action(), is_empty(), is_game_over(), is_in_sunlight(), is_sheltered(), knockback(), list_items(), list_monsters(), load(), load_map(), load_npcs(), look_around(), mon_info_update(), monmove(), moving_vehicle_dismount(), peek(), perhaps_add_random_npc(), phasing_move(), pickup(), place_critter_around(), place_player(), place_player_overmap(), place_vehicle_nearby(), pre_print_all_tile_info(), print_all_tile_info(), print_fields_info(), print_graffiti_info(), print_items_info(), print_terrain_info(), print_trap_info(), process_artifact(), prompt_dangerous_tile(), remoteveh(), save_maps(), serialize(), setup(), shift_monsters(), start_game(), start_hauling(), swap_critters(), try_get_left_click_action(), try_get_right_click_action(), update_map(), update_stair_monsters(), use_computer(), validate_camps(), validate_linked_vehicles(), validate_mounted_npcs(), vertical_move(), vertical_notes(), vertical_shift(), walk_move(), and zones_manager().

◆ main_ui_adaptor

weak_ptr_fast<ui_adaptor> game::main_ui_adaptor
private

◆ map_ptr

pimpl<map> game::map_ptr
private

Definition at line 946 of file game.h.

◆ memorial_logger_ptr

pimpl<memorial_logger> game::memorial_logger_ptr
private

Definition at line 956 of file game.h.

Referenced by game(), and memorial().

◆ monstairz

int game::monstairz = 0

Definition at line 983 of file game.h.

Referenced by update_stair_monsters(), and vertical_move().

◆ mostseen

int game::mostseen = 0

◆ moves_since_last_save

int game::moves_since_last_save = 0
private

Definition at line 1039 of file game.h.

Referenced by do_turn(), get_moves_since_last_save(), init_autosave(), quickload(), and quicksave().

◆ new_game

bool game::new_game = false

True if the game has just started or loaded, else false.

Definition at line 979 of file game.h.

Referenced by do_turn(), setup(), and start_game().

◆ next_mission_id

int game::next_mission_id = 0
private

Definition at line 1037 of file game.h.

Referenced by assign_mission_id(), serialize_master(), setup(), and unserialize_master().

◆ next_npc_id

character_id game::next_npc_id
private

Definition at line 1035 of file game.h.

Referenced by assign_npc_id(), serialize_master(), setup(), and unserialize_master().

◆ npcs_dirty

bool game::npcs_dirty = false
private

Has a NPC been spawned since last load?

Definition at line 1046 of file game.h.

Referenced by do_turn(), load_npcs(), and set_npcs_dirty().

◆ queue_screenshot

bool game::queue_screenshot = false

Definition at line 1018 of file game.h.

Referenced by do_turn().

◆ remoteveh_cache

vehicle* game::remoteveh_cache
private

Definition at line 1044 of file game.h.

Referenced by remoteveh(), setremoteveh(), and setup().

◆ remoteveh_cache_time

time_point game::remoteveh_cache_time
private

Definition at line 1043 of file game.h.

Referenced by remoteveh(), setremoteveh(), and setup().

◆ right_sidebar

bool game::right_sidebar = false

Definition at line 1014 of file game.h.

◆ safe_mode

◆ safe_mode_warning_logged

bool game::safe_mode_warning_logged = false
private

Definition at line 1033 of file game.h.

Referenced by check_safe_mode_allowed(), handle_action(), and set_safe_mode().

◆ scen

const scenario* game::scen = nullptr

Definition at line 981 of file game.h.

Referenced by start_calendar(), and start_game().

◆ scent

scent_map& game::scent

Definition at line 964 of file game.h.

Referenced by display_scent(), do_turn(), serialize(), setup(), unserialize(), update_map(), and vertical_shift().

◆ scent_ptr

pimpl<scent_map> game::scent_ptr
private

Definition at line 950 of file game.h.

◆ seed

unsigned int game::seed = 0
private

Seed for all the random numbers that should have consistent randomness (weather).

Definition at line 1062 of file game.h.

Referenced by get_seed(), serialize_master(), start_game(), and unserialize_master().

◆ sFilter

std::string game::sFilter
private

Definition at line 1029 of file game.h.

Referenced by list_items(), and reset_item_list_state().

◆ show_panel_adm

bool game::show_panel_adm = false

Definition at line 1013 of file game.h.

Referenced by draw_panels(), and load_static_data().

◆ spell_events_ptr

pimpl<spell_events> game::spell_events_ptr
private

Definition at line 957 of file game.h.

Referenced by game(), and spell_events_subscriber().

◆ stats_tracker_ptr

pimpl<stats_tracker> game::stats_tracker_ptr
private

Definition at line 953 of file game.h.

Referenced by game(), serialize(), stats(), and unserialize().

◆ ter_view_p

tripoint game::ter_view_p

Definition at line 985 of file game.h.

Referenced by draw(), and draw_ter().

◆ tileset_zoom

int game::tileset_zoom = 0
private

How far the tileset should be zoomed out, 16 is default.

32 is zoomed in by x2, 8 is zoomed out by x0.5

Definition at line 1059 of file game.h.

Referenced by get_zoom(), look_around(), mouse_edge_scrolling_terrain(), reset_zoom(), set_zoom(), zoom_in(), and zoom_out().

◆ timed_event_manager_ptr

pimpl<timed_event_manager> game::timed_event_manager_ptr
private

Definition at line 951 of file game.h.

◆ timed_events

timed_event_manager& game::timed_events

Definition at line 965 of file game.h.

Referenced by do_turn(), natural_light_level(), and setup().

◆ token_provider_ptr

pimpl<drop_token_provider> game::token_provider_ptr

Definition at line 974 of file game.h.

Referenced by serialize(), setup(), and unserialize().

◆ turnssincelastmon

int game::turnssincelastmon = 0

Definition at line 1020 of file game.h.

Referenced by handle_action(), mon_info_update(), and setup().

◆ u

avatar& game::u

Definition at line 963 of file game.h.

Referenced by add_artifact_dreams(), add_npc_follower(), autopilot_vehicles(), cata_event_dispatch::avatar_moves(), butcher(), calc_driving_offset(), cancel_activity_or_ignore_query(), cancel_activity_query(), catch_a_monster(), centerlistview(), chat(), check_safe_mode_allowed(), cleanup_at_end(), control_vehicle(), create_starting_npcs(), critter_at(), critter_by_id(), death_screen(), disable_robot(), disp_NPCs(), display_scent(), do_turn(), draw(), draw_critter(), draw_critter_highlighted(), draw_critter_internal(), draw_hit_mon(), draw_line(), draw_look_around_cursor(), draw_minimap(), draw_panels(), draw_ter(), draw_trail_to_square(), draw_veh_dir_indicator(), drop(), drop_in_direction(), exam_vehicle(), examine(), extended_description(), find_nearby_items(), find_or_make_stairs(), fling_creature(), forced_door_closing(), fungal_effects::fungalize(), get_dangerous_tile(), get_player_input(), get_veh_dir_indicator_location(), grabbed_furn_move(), grabbed_move(), grabbed_veh_move(), handle_action(), handle_key_blocking_activity(), inv_map_splice(), is_game_over(), is_hostile_within(), is_in_viewport(), item_action_menu(), knockback(), list_items(), list_items_monsters(), list_missions(), list_monsters(), load(), look_around(), mon_info(), mon_info_update(), monmove(), move_save_to_graveyard(), moving_vehicle_dismount(), npc_menu(), on_move_effects(), open_consume_item_menu(), overmap_npc_move(), peek(), perhaps_add_random_npc(), phasing_move(), pickup_feet(), place_player(), place_player_overmap(), print_all_tile_info(), print_creature_info(), print_items_info(), print_terrain_info(), print_trap_info(), process_activity(), process_artifact(), process_voluntary_act_interrupt(), prompt_dangerous_tile(), quickload(), remoteveh(), remove_npc_follower(), save(), save_player_data(), serialize(), set_driving_view_offset(), setremoteveh(), shared_from(), slip_down(), fungal_effects::spread_fungus_one_tile(), start_game(), start_hauling(), toggle_gate(), try_get_left_click_action(), try_get_right_click_action(), unserialize(), update_map(), update_overmap_seen(), update_stair_monsters(), use_computer(), validate_camps(), validate_npc_followers(), vertical_move(), vertical_notes(), vertical_shift(), walk_move(), win(), win_screen(), and zones_manager().

◆ u_ptr

pimpl<avatar> game::u_ptr
private

Definition at line 947 of file game.h.

◆ u_shared_ptr

shared_ptr_fast<player> game::u_shared_ptr
private

Definition at line 1024 of file game.h.

Referenced by shared_from().

◆ uquit

quit_status game::uquit

Used in main.cpp to determine what type of quit is being performed.

Definition at line 977 of file game.h.

Referenced by cleanup_at_end(), do_turn(), get_player_input(), handle_action(), is_game_over(), and setup().

◆ user_action_counter

int game::user_action_counter = 0
private

Definition at line 1056 of file game.h.

Referenced by get_user_action_counter(), and handle_action().

◆ w_minimap

catacurses::window game::w_minimap

Definition at line 989 of file game.h.

Referenced by create_or_get_main_ui_adaptor(), and draw_minimap().

◆ w_minimap_ptr

catacurses::window game::w_minimap_ptr
private

Definition at line 1027 of file game.h.

Referenced by create_or_get_main_ui_adaptor().

◆ w_omlegend

catacurses::window game::w_omlegend

Definition at line 988 of file game.h.

◆ w_overmap

catacurses::window game::w_overmap

Definition at line 987 of file game.h.

◆ w_pixel_minimap

catacurses::window game::w_pixel_minimap

◆ w_terrain

◆ w_terrain_ptr

catacurses::window game::w_terrain_ptr
private

Definition at line 1026 of file game.h.

Referenced by create_or_get_main_ui_adaptor().

◆ wait_popup

std::unique_ptr<static_popup> game::wait_popup
private

Definition at line 1075 of file game.h.

Referenced by do_turn().

◆ was_fullscreen

bool game::was_fullscreen = false

Definition at line 1016 of file game.h.

Referenced by load_static_data(), reenter_fullscreen(), and temp_exit_fullscreen().

◆ weather_manager_ptr

pimpl<weather_manager> game::weather_manager_ptr
private

Definition at line 959 of file game.h.

◆ zones_manager_open

bool game::zones_manager_open = false
private

Is Zone manager open or not - changes graphics of some zone tiles.

Definition at line 1052 of file game.h.

Referenced by is_zones_manager_open(), and zones_manager().


The documentation for this class was generated from the following files: